/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package m.oms.ages;

import csip.ModelDataService;
import csip.ServiceException;
import csip.annotations.*;
import static csip.annotations.ResourceType.*;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.ws.rs.Path;
import static m.oms.ages.V1_0.KEY_SCRIPT;
import ngmf.util.cosu.luca.of.KGE;
import ngmf.util.cosu.luca.of.NS;
import ngmf.util.cosu.luca.of.RMSE;
import ngmf.util.cosu.luca.of.TRMSE;
import oms.utils.Utils;
import oms.utils.Utils.PBIAS;
import oms.utils.Utils.NSLOG;
import oms.utils.Utils.NSLOG1P;
import oms.utils.Utils.NS2LOGOP;
import oms3.ObjectiveFunction;

/**
 * Ages service.
 *
 * @author od
 */
@Name("AGES model execution")
@Description("OMS based AGES model service")
@VersionInfo("1.0")
@Path("m/ages/0.3.0")
@Resource(file = "/bin/ages/ages.jar", type = JAR, id = Utils.ID_AGES_JAR)
@Resource(file = "/bin/ages/ages-lib.zip", type = ARCHIVE)
@Resource(file = "/bin/ages/ages-static.zip", type = ARCHIVE)
@Resource(file = "java-*-std*.txt output/csip_run/out/*.csv", type = OUTPUT)
@Resource(file = "${csip.dir}/bin/ages/simulation/ages.sim", type = REFERENCE, id = KEY_SCRIPT)
public class V1_0 extends ModelDataService {

    public static final String KEY_SCRIPT = "ages.sim";
    public static final String RUN_INC = "run.inc";

    public static final String PAR_STARTTIME = "startTime";
    public static final String PAR_ENDTIME = "endTime";

    public static final String CAL_STARTTIME = "cal_startTime";
    public static final String CAL_ENDTIME = "cal_endTime";

    static final Map<String, ObjectiveFunction> OF = new HashMap<>();

    static {
        OF.put("kge", new KGE());
        OF.put("ns", new NS());
        OF.put("nslog", new NSLOG());
        OF.put("nslog1p", new NSLOG1P());
        OF.put("nslogop", new NS2LOGOP());
        OF.put("rmse", new RMSE());
        OF.put("trmse", new TRMSE());
        OF.put("pbias", new PBIAS());
    }

    // required parameter
    String[] reqParams = {
        PAR_STARTTIME,
        PAR_ENDTIME
    };

    // optional parameter
    String[] optParams = {
        "ACAdaptation",
        "BetaW",
        "Beta_min",
        "Beta_rsd",
        "FCAdaptation",
        "Ksink",
        "LExCoef",
        "N_delay_RG1",
        "N_delay_RG2",
        "a_rain",
        "a_snow",
        "angstrom_a",
        "angstrom_b",
        "baseTemp",
        "calib_clat_fact",
        "ccf_factor",
        "defaultCO2",
        "denitfac",
        "delayNitrification",
        "denitrificationRateCoefficient",
        "denitrificationSoilSaturationThreshold",
        "depdr",
        "deposition_factor",
        "drrad",
        "drspac",
        "f1",
        "f12",
        "f13",
        "f14",
        "f15",
        "f16",
        "f17",
        "f18",
        "f19",
        "f2",
        "f3",
        "f4",
        "f5",
        "f6",
        "f7",
        "f8",
        "flowRouteTA",
        "fmt_date",
        "fmt_double",
        "g_factor",
        "geoMaxPerc",
        "gwCapRise",
        "gwRG1Fact",
        "gwRG1RG2dist",
        "gwRG2Fact",
        "halflife_RG1",
        "halflife_RG2",
        "infil_conc_factor",
        "initLPS",
        "initMPS",
        "initN_concRG1",
        "initN_concRG2",
        "initRG1",
        "initRG2",
        "kdiff_layer",
        "kf_calib",
        "lagSurfaceRunoff",
        "lagInterflow",
        "locGrw",
        "longTZ",
        "nitri_delay",
        "nitrificationSoilTemperatureThreshold",
        "nitrificationSurfaceTemperatureThreshold",
        "opti",
        "piadin",
        "r_factor",
        "rootfactor",
        "sceno",
        "skipRegression",
        "snowCritDens",
        "snowDensConst",
        "snowFactorA",
        "snowFactorB",
        "snowFactorC",
        "snow_trans",
        "snow_trs",
        "soilDiffMPSLPS",
        "soilDistMPSLPS",
        "soilImpGT80",
        "soilImpLT80",
        "soilLatVertLPS",
        "soilLinRed",
        "soilMaxDPS",
        "soilMaxInfSnow",
        "soilMaxInfSummer",
        "soilMaxInfWinter",
        "soilMaxPerc",
        "soilOutLPS",
        "soilPolRed",
        "t_factor",
        "tempRes",
        "temp_lag"
    };

    // simulation flags
    String[] flags = {
        "flagParallel",
        "flagRegionalization",
        "flagHRURouting",
        "flagReachRouting",
        "flagSort",
        "flagSplit",
        "flagInfiltration",
        "flagTillage",
        "flagTileDrain",
        "flagUPGM",
        "parallelismFactor",
        "parallelismThreads",
        "flagSaveState",
        "flagLoadState",
        "flagWB"
    };

    @Override
    public void doProcess() throws Exception {
        String dsl = parameter().getString(KEY_SCRIPT,
                resources().getFile(KEY_SCRIPT).toString());

        // pass request param to model runtime parameter -> run.inc
        Map<String, String> agesParam = new LinkedHashMap<>();
        Utils.passReqQuotedParam(agesParam, parameter(), reqParams);

        // scalar parameter
        Utils.passOptParam(agesParam, parameter(), optParams);

        // optional flags
        Utils.passOptQuotedParam(agesParam, parameter(), flags);

        // create parameter include file
        Utils.createParamInclude(agesParam, getWorkspaceFile(RUN_INC));

        String start = parameter().getString(PAR_STARTTIME);
        String end = parameter().getString(PAR_ENDTIME);

        // optional parameter
        String cal_start = parameter().getString(CAL_STARTTIME, start);
        String cal_end = parameter().getString(CAL_ENDTIME, end);

        File d = new File(dsl);
        if (!(d.isAbsolute() && d.exists())) {
            d = getWorkspaceFile(dsl);
        }

        getWorkspaceFile("output").mkdirs();
        getWorkspaceFile("logs").mkdirs();

        Utils.runAges(d, getWorkspaceDir(), parameter(), resources(), LOG);

        for (String ofName : getRequestedObjfunc(OF.keySet())) {
            String[] data = parameter().getStringArray(ofName);
            double v = calc_of(OF.get(ofName), data[0], data[1], cal_start, cal_end);
            results().put(ofName, v);
        }
//  results().put(getWorkspaceFile("output"));
    }

    private List<String> getRequestedObjfunc(Set<String> names) {
        List<String> l = new ArrayList<>();
        for (String ofName : names) {
            if (parameter().has(ofName)) {
                l.add(ofName);
            }
        }
        return l;
    }

    private double calc_of(ObjectiveFunction of, String obs,
            String sim, String start, String end) throws IOException, ServiceException {
        // e.g. obs_data02_14.csv/obs/orun[1]
        double[] obsData = Utils.getData(obs, getWorkspaceDir(), start, end);
        // e.g. output/csip_run/out/Outlet.csv/output/catchmentSimRunoff
        double[] simData = Utils.getData(sim, getWorkspaceDir(), start, end);
        return of.calculate(obsData, simData, parameter().getDouble("missing", -9999d));
    }

}