/* This is Free Software under GNU Affero General Public License v >= 3.0
 * without warranty, see README.md and license for details.
 *
 * SPDX-License-Identifier: AGPL-3.0-or-later
 * License-Filename: LICENSES/AGPL-3.0.txt
 *
 * Copyright (C) 2018 by via donau
 *   – Österreichische Wasserstraßen-Gesellschaft mbH
 * Software engineering by Intevation GmbH
 *
 * Author(s):
 * Thomas Junk <thomas.junk@intevation.de>
 */

import { HTTP } from "@/lib/http";
import { format, subYears } from "date-fns";

const LNWLDIAGRAMMOCKDATA = {
  lnwl: [
    { level: "LDC", value: 162, percent: 40 },
    { level: "HDC", value: 564, percent: 60 }
  ],
  afd: [
    { value: 200, percent: 30 },
    { value: 230, percent: 50 },
    { value: 250, percent: 20 }
  ]
};

const FREQUENCIES = {
  MONTHLY: "monthly",
  QUARTERLY: "quarterly",
  YEARLY: "yearly"
};

const init = () => {
  return {
    type: "bottlenecks",
    selectedFairwayAvailabilityFeature: null,
    to: format(new Date(), "YYYY-MM-DD"),
    from: format(subYears(new Date(), 1), "YYYY-MM-DD"),
    frequency: FREQUENCIES.MONTHLY,
    depthlimit1: 250,
    depthlimit2: 230,
    breadthlimit1: null,
    breadthlimit2: null,
    fwData: null,
    fwLNWLData: null,
    fwLNWLOverviewData: [],
    legendLNWL: null,
    legend: null,
    LOS: 3
  };
};

const fairwayavailability = {
  init,
  namespaced: true,
  state: init(),
  getters: {
    fwLNWLOverviewData: state => feature => {
      return state.fwLNWLOverviewData.find(
        d => d.feature.get("id") === feature.get("id")
      );
    }
  },
  mutations: {
    type: (state, type) => {
      state.type = type;
    },
    setLOS: (state, LOS) => {
      state.LOS = LOS;
    },
    setFrequency: (state, frequency) => {
      state.frequency = frequency;
    },
    setFrom: (state, from) => {
      state.from = from;
    },
    setTo: (state, to) => {
      state.to = to;
    },
    setDepthlimit1: (state, depthlimit1) => {
      state.depthlimit1 = depthlimit1;
    },
    setDepthlimit2: (state, depthlimit2) => {
      state.depthlimit2 = depthlimit2;
    },
    setBreadthlimit1: (state, breadthlimit1) => {
      state.breadthlimit1 = breadthlimit1;
    },
    setBreadthlimit2: (state, breadthlimit2) => {
      state.breadthlimit2 = breadthlimit2;
    },
    setSelectedFairwayAvailability: (state, feature) => {
      state.selectedFairwayAvailabilityFeature = feature;
    },
    setFwData: (state, fwData) => {
      state.fwData = fwData;
    },
    setFwLNWLData: (state, fwLNWLData) => {
      state.fwLNWLData = fwLNWLData;
    },
    addFwLNWLOverviewData: (state, data) => {
      let existingIndex = state.fwLNWLOverviewData.findIndex(
        d => d.feature.get("id") === data.feature.get("id")
      );
      if (existingIndex !== -1)
        state.fwLNWLOverviewData.splice(existingIndex, 1);
      state.fwLNWLOverviewData.push(data);
    },
    setLegend: (state, header) => {
      const headerEntries = header.split(",");
      headerEntries.shift();
      state.legend = headerEntries.map(x => {
        let entry = x.split("#")[1]; // split leading #
        entry = entry.replace("[h]", "").trim(); // omit unit
        return entry;
      });
    },
    setLegendLNWL: (state, headerLNWL) => {
      this.headerLNWL = headerLNWL;
    }
  },
  actions: {
    loadAvailableFairwayDepth: ({ commit }, options) => {
      return new Promise((resolve, reject) => {
        const { feature, from, to, frequency, LOS } = options;
        let name =
          feature.constructor.name === "Feature"
            ? feature.get("objnam")
            : feature.properties.name;
        const start = encodeURIComponent("00:00:00+00:00");
        const end = encodeURIComponent("23:59:59+00:00");
        const URL = `/data/bottleneck/fairway-depth/${encodeURIComponent(
          name
        )}?from=${from}T${start}&to=${to}T${end}&mode=${frequency}&los=${LOS}`;
        HTTP.get(URL, {
          headers: { "X-Gemma-Auth": localStorage.getItem("token") }
        })
          .then(response => {
            const { data } = response;
            const csv = data.split("\n").filter(x => x !== ""); //omit empty lines
            commit("setLegend", csv.shift());
            let transformed = csv.map(e => {
              const result = e.split(",");
              const label = result.shift();
              const ldc = result.shift();
              const highestLevel = result.pop();
              const sum = result.reduce((x, y) => Number(x) + Number(y));
              let last = 0;
              const levelsWithSum = result.map(x => {
                let result = {
                  height: Number(x),
                  translateY: sum - (last + Number(x))
                };
                last = last + Number(x);
                return result;
              });
              return {
                label: label,
                ldc: ldc,
                highestLevel: highestLevel,
                lowerLevels: levelsWithSum
              };
            });
            commit("setFwData", transformed);
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    loadAvailableFairwayDepthLNWL: (context, options) => {
      return new Promise((resolve, reject) => {
        const { feature, from, to, frequency, LOS } = options;
        let name =
          feature.constructor.name === "Feature"
            ? feature.get("objnam")
            : feature.properties.name;
        const start = encodeURIComponent("00:00:00+00:00");
        const end = encodeURIComponent("23:59:59+00:00");
        const URL = `/data/bottleneck/availability/${encodeURIComponent(
          name
        )}?from=${from}T${start}&to=${to}T${end}&mode=${frequency}&los=${LOS}`;
        HTTP.get(URL, {
          headers: { "X-Gemma-Auth": localStorage.getItem("token") }
        })
          .then(response => {
            resolve(response.data);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    loadAvailableFairwayDepthLNWLDiagram: ({ commit, dispatch }, options) => {
      dispatch("loadAvailableFairwayDepthLNWL", options).then(response => {
        //const data = response;
        let data = LNWLDIAGRAMMOCKDATA;
        Object.keys(data).forEach(diagramComponent => {
          let sum = 0;
          data[diagramComponent].map(elem => {
            elem["translateY"] = Number(elem["percent"]) + sum;
            sum += Number(elem["percent"]);
            return elem;
          });
        });
        commit("setFwLNWLData", data);
      });
    }
  }
};

export { FREQUENCIES, fairwayavailability };