/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package models;

import csip.ServiceException;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import data.interpretors.CligenData;
import data.interpretors.IFCFile;
import data.interpretors.WindGenData;
import java.io.BufferedWriter;
import java.io.File;
import java.nio.file.Files;
import java.util.logging.Level;
import java.util.logging.Logger;
import nodes.WEPSManagement;
import org.codehaus.jettison.json.JSONArray;
import parsers.ParserException;
import utils.Urls;

/**
 *
 * @author <a href="mailto:shaun.case@colostate.edu">Shaun Case</a>
 */
public class WEPSModelArchive extends ModelArchive {

  private IFCFile ifcFile;
  private WindGenData windData;
  private CligenData cligenData;
  private String stdErrorFile;
  private String stdOutFile;
  private WEPSManagement management;
  private boolean possibleBadModelRun = false;
  private boolean badModelRun = false;
  private String badModelMessage = "";
  private WEPSMetaData wepsMetaData;

  public WEPSModelArchive(String suid, String ctime, String etime, String service, String status, String req_ip, String filename) {
    super(suid, ctime, etime, service, status, req_ip, filename);
  }

  public WEPSModelArchive(String suid, String ctime, String etime, String service, String status, String req_ip, String filename, byte[] fileData) throws IOException, JSONException {
    super(suid, ctime, etime, service, status, req_ip, filename, fileData);
    setFileDataEx(fileData);
  }

  public WEPSModelArchive(JSONObject metaData) throws JSONException {
    super(metaData);
  }

  public WEPSModelArchive(JSONObject metaData, byte[] fileData) throws JSONException, IOException {
    super(metaData);
    setFileDataEx(fileData);
  }

  @Override
  public final void setFileDataEx(byte[] fileData) throws IOException, JSONException {
    super.setFileDataEx(fileData);

    try {
      stdErrorFile = getStdErrorFile(fileData);
    } catch (IOException ex) {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += ex.getMessage();
    }
    if (null != stdErrorFile) {
      possibleBadModelRun = stdErrorFile.contains("IEEE_UNDERFLOW_FLAG") || stdErrorFile.contains("IEEE_DENORMAL");

      if (possibleBadModelRun) {
        badModelMessage += "##\nThe WEPS model executable stderr file contained: ";
        badModelMessage += ((stdErrorFile.contains("IEEE_UNDERFLOW_FLAG")) ? "\nIEEE_UNDERFLOW_FLAG, Meaning that some values were rounded to zero because they were too small for the FORTRAN code to interpret." : "");
        if (badModelMessage.contains("IEEE")) {
          badModelMessage += "\n AND ";
        }
        badModelMessage += ((stdErrorFile.contains("IEEE_DENORMAL")) ? "\nIEEE_DENORMAL, Meaning that there are denormal numbers generated when running the code." : "");
        badModelMessage += "\n This may be a hint about numerical problems in the model FORTRAN code, but it is not an error per se. Probably, the program finished successfully, but some result values may be suspect.";
      }
    }

//        try {
//            management = getManagementFile(fileData);
//        } catch (IOException ex) {
//            badModelRun = true;
//            badModelMessage += "##\n";
//            badModelMessage += ex.getMessage();
//        }
    try {
      windData = getWindDataFile(fileData);
    } catch (IOException ex) {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += ex.getMessage();
    }

    if (windData.badWindData()) {
      badModelMessage += "##\nThe Wind data associated with this model run has some qualifying messages: \n" + windData.windDataMessages();
    }

    try {
      cligenData = getClimateDataFile(fileData);
    } catch (IOException ex) {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += ex.getMessage();
    }

    if (cligenData.badClimateData()) {
      badModelMessage += "##\nThe Cligen data associated with this model run has some qualifying messages: \n" + cligenData.cligenDataMessages();
    }

    try {
      stdOutFile = getStdOutFile(fileData);
    } catch (IOException ex) {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += ex.getMessage();
    }

    try {
      ifcFile = getIFCFile(fileData);
    } catch (IOException ex) {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += ex.getMessage();
    }

    if (!badModelRun && badModelMessage.isEmpty()) {
      calcWEPSMetaData();
    }
  }

  public boolean questionableResults() {
    return possibleBadModelRun;
  }

  public boolean badModelRun() {
    return badModelRun;
  }

  public String badModelMessage() {
    return badModelMessage;
  }

  public IFCFile iFCFile() {
    return ifcFile;
  }

  public WindGenData windData() {
    return windData;
  }

  public CligenData cligenData() {
    return cligenData;
  }

  public String stdErrorFile() {
    return stdErrorFile;
  }

  public String stdOutFile() {
    return stdOutFile;
  }

  public WEPSMetaData getWEPSMetaData() {
    return wepsMetaData;
  }

  public void calcWEPSMetaData() {
    if (null == wepsMetaData) {
      wepsMetaData = new WEPSMetaData();
    }

    wepsMetaData.suid(this.suid);
    wepsMetaData.cokey(getOriginalRequest("soil"));
    wepsMetaData.longitude(Double.parseDouble(getOriginalRequest("longitude")));
    wepsMetaData.latitude(Double.parseDouble(getOriginalRequest("latitude")));
    wepsMetaData.annualPrecip(cligenData.annualAvgPrecip());
    wepsMetaData.windEnergy(windData.simulationAverage());
    wepsMetaData.componentName(ifcFile.componentName);
    wepsMetaData.fractionSand(ifcFile.fractionSand);
    wepsMetaData.fractionSilt(ifcFile.fractionSilt);
    wepsMetaData.fractionClay(ifcFile.fractionClay);
    wepsMetaData.crustStability(ifcFile.crustStability);
    wepsMetaData.surfRockFrag(ifcFile.surfaceFragmentCover);
    wepsMetaData.albedo(ifcFile.surfaceAlbedo);
    wepsMetaData.num_layers(ifcFile.layerThickness.length);
    wepsMetaData.surface_thickness(((int) ifcFile.layerThickness[0]));
    wepsMetaData.slope_gradient(ifcFile.surfaceSlope);

    //TODO:  Do we need to measure the layers before setting these??  WEPSSoilInput already filters/sorts layers, etc...
    wepsMetaData.aggStability(ifcFile.aggregateStability[0]);
    wepsMetaData.soilWiltPoint(ifcFile.wiltingPointSWC[0]);
    wepsMetaData.aggGeomDiam(ifcFile.aggregateMeanDiameter[0]);

    String biomass_avg = getOriginalResponse("average_biomass");
    if (!biomass_avg.isEmpty()) {
      wepsMetaData.rotWeightResBiomass(Double.parseDouble(biomass_avg) * 2000);
    } else {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += "Missing biomass_avg result in WEPS output result file.";
    }

    String stir_avg = getOriginalResponse("avg_all_stir");
    if (!stir_avg.isEmpty()) {
      wepsMetaData.rotWeightSoilTillIntensity(Double.parseDouble(stir_avg));
    } else {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += "Missing avg_all_stir result in WEPS output result file.";
    }

    String wind_eros = getOriginalResponse("wind_eros");
    if (!wind_eros.isEmpty()) {
      wepsMetaData.erosionRate(Double.parseDouble(wind_eros));
    } else {
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += "Missing wind_eros result in WEPS output result file.";
    }

    wepsMetaData.errorMessages(badModelMessage);

  }

  private WEPSManagement getManagementFile(byte[] fileData) throws IOException {
    WEPSManagement wepsManagement = new WEPSManagement(new Urls());

    File managementFile = new File("management.man");
    BufferedWriter bufferWriter = Files.newBufferedWriter(managementFile.toPath());
    String data = getFileContents(fileData, ".man");
    bufferWriter.write(data);
    bufferWriter.flush();
    bufferWriter.close();

    try {
      wepsManagement.readManData(managementFile);
    } catch (ParserException | ServiceException ex) {
      Logger.getLogger(WEPSModelArchive.class.getName()).log(Level.SEVERE, null, ex);
      badModelRun = true;
      badModelMessage += "##\n";
      badModelMessage += "Error parsing the WEPS management file:  " + ex.getMessage();
    }

    return wepsManagement;
  }

  private WindGenData getWindDataFile(byte[] fileData) throws IOException {
    WindGenData wind;

    wind = new WindGenData(getFileContents(fileData, ".win"));

    return wind;
  }

  private CligenData getClimateDataFile(byte[] fileData) throws IOException {
    CligenData climate;

    climate = new CligenData(getFileContents(fileData, ".cli"));

    return climate;
  }

  private IFCFile getIFCFile(byte[] fileData) throws IOException {
    IFCFile requestData;

    requestData = new IFCFile(getFileContents(fileData, ".ifc"));

    return requestData;
  }

  private String getStdErrorFile(byte[] fileData) throws IOException {
    String fileString = null;

    try (ZipInputStream zin = new ZipInputStream(new ByteArrayInputStream(fileData))) {
      ZipEntry entry;

      while ((entry = zin.getNextEntry()) != null) {
        if (entry.getName().contains("weps.") && entry.getName().contains("stderr.txt")) {
          BufferedReader bReader = new BufferedReader(new InputStreamReader(zin));
          StringBuilder fileContent = new StringBuilder();
          String inputStr;
          while ((inputStr = bReader.readLine()) != null) {
            fileContent.append(inputStr).append(System.lineSeparator());
          }
          fileString = fileContent.toString();
          break;
        }
      }
    }

    return fileString;
  }

  private String getStdOutFile(byte[] fileData) throws IOException {
    String fileString = null;

    try (ZipInputStream zin = new ZipInputStream(new ByteArrayInputStream(fileData))) {
      ZipEntry entry;

      while ((entry = zin.getNextEntry()) != null) {
        if (entry.getName().contains("weps.exe") && entry.getName().contains("stdout.txt")) {
          BufferedReader bReader = new BufferedReader(new InputStreamReader(zin));
          StringBuilder fileContent = new StringBuilder();
          String inputStr;
          while ((inputStr = bReader.readLine()) != null) {
            fileContent.append(inputStr).append(System.lineSeparator());
          }
          fileString = fileContent.toString();
          break;
        }
      }
    }

    return fileString;
  }

  public class WEPSMetaData {

    private double latitude;
    private double longitude;
    private String cokey;
    private double windEnergy;
    private double annualPrecip;
    private double rotIrrEffect;
    private double soilWiltPoint;
    private double rotWeightResBiomass;
    private double rotWeightSoilTillIntensity;
    private double rotWeightResAddition;
    private double aggStability;
    private double aggGeomDiam;
    private double crustStability;
    private double surfRockFrag;
    private double erosionRate;
    private String componentName;
    private double[] fractionSand;
    private double[] fractionSilt;
    private double[] fractionClay;
    private double albedo;
    private double slope_gradient;
    private int surface_thickness;
    private int num_layers;
    private String suid;
    private String errorMessages = "";

    public String errorMessages() {
      return errorMessages;
    }

    public void errorMessages(String value) {
      errorMessages = value;
    }

    public String suid() {
      return suid;
    }

    public void suid(String value) {
      suid = value;
    }

    public double windEnergy() {
      return windEnergy;
    }

    public double annualPrecip() {
      return annualPrecip;
    }

    public double rotIrrEffect() {
      return rotIrrEffect;
    }

    public double soilWiltPoint() {
      return soilWiltPoint;
    }

    public double rotWeightResBiomass() {
      return rotWeightResBiomass;
    }

    public double rotWeightSoilTillIntensity() {
      return rotWeightSoilTillIntensity;
    }

    public double rotWeightResAddition() {
      return rotWeightResAddition;
    }

    public double aggStability() {
      return aggStability;
    }

    public double aggGeomDiam() {
      return aggGeomDiam;
    }

    public double crustStability() {
      return crustStability;
    }

    public double surfRockFrag() {
      return surfRockFrag;
    }

    public double erosionRate() {
      return erosionRate;
    }

    public void windEnergy(double value) {
      windEnergy = value;
    }

    public void annualPrecip(double value) {
      annualPrecip = value;
    }

    public void rotIrrEffect(double value) {
      rotIrrEffect = value;
    }

    public void soilWiltPoint(double value) {
      soilWiltPoint = value;
    }

    public void rotWeightResBiomass(double value) {
      rotWeightResBiomass = value;
    }

    public void rotWeightSoilTillIntensity(double value) {
      rotWeightSoilTillIntensity = value;
    }

    public void rotWeightResAddition(double value) {
      rotWeightResAddition = value;
    }

    public void aggStability(double value) {
      aggStability = value;
    }

    public void aggGeomDiam(double value) {
      aggGeomDiam = value;
    }

    public void crustStability(double value) {
      crustStability = value;
    }

    public void surfRockFrag(double value) {
      surfRockFrag = value;
    }

    public void erosionRate(double value) {
      erosionRate = value;
    }

    public String componentName() {
      return componentName;
    }

    public double fractionSand(int index) {
      if ((null != fractionSand) && (index < fractionSand.length)) {
        return fractionSand[index];
      }
      return Double.NaN;
    }

    public double fractionSilt(int index) {
      if ((null != fractionSand) && (index < fractionSilt.length)) {
        return fractionSilt[index];
      }
      return Double.NaN;
    }

    public double fractionClay(int index) {
      if ((null != fractionSand) && (index < fractionClay.length)) {
        return fractionClay[index];
      }
      return Double.NaN;
    }

    public void componentName(String value) {
      componentName = value;
    }

    public void fractionSand(double[] value) {
      fractionSand = value;
    }

    public void fractionSilt(double[] value) {
      fractionSilt = value;
    }

    public void fractionClay(double[] value) {
      fractionClay = value;
    }

    public void albedo(double value) {
      albedo = value;
    }

    public void slope_gradient(double value) {
      slope_gradient = value;
    }

    public void surface_thickness(int value) {
      surface_thickness = value;
    }

    public void num_layers(int value) {
      num_layers = value;
    }

    public double albedo() {
      return albedo;
    }

    public double slope_gradient() {
      return slope_gradient;
    }

    public int surface_thickness() {
      return surface_thickness;
    }

    public int num_layers() {
      return num_layers;
    }

    public double latitude() {
      return latitude;
    }

    public double longitude() {
      return longitude;
    }

    public String cokey() {
      return cokey;
    }

    public void latitude(double value) {
      latitude = value;
    }

    public void longitude(double value) {
      longitude = value;
    }

    public void cokey(String value) {
      cokey = value;
    }

    public JSONArray toJSON() throws JSONException {
      JSONArray ret_val = new JSONArray();
      JSONObject results = new JSONObject();

      results.put("weps_archive_suid", wepsMetaData.suid());
      results.put("annual_precipitation", wepsMetaData.annualPrecip());
      results.put("wind_energy", wepsMetaData.windEnergy());
      results.put("crust_stability", wepsMetaData.crustStability());
      results.put("surface_rock_fragments", wepsMetaData.surfRockFrag());
      results.put("aggregate_stability", wepsMetaData.aggStability());
      results.put("soil_wilting_poiont", wepsMetaData.soilWiltPoint());
      results.put("rotation_weighted_biomass", wepsMetaData.rotWeightResBiomass());
      results.put("annual_precipitation", wepsMetaData.annualPrecip());

      results.put("rotation_weighted_soil_tillage_intensity", wepsMetaData.rotWeightSoilTillIntensity());
      results.put("erosion_rate", wepsMetaData.erosionRate());

      ret_val.put(results);
      return ret_val;
    }
  }
}