/* 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 { WFS } from "ol/format.js";
import { equalTo as equalToFilter } from "ol/format/filter.js";

/* eslint-disable no-unused-vars */
/* eslint-disable no-unreachable */
const STATES = {
  NEEDSAPPROVAL: "pending",
  APPROVED: "accepted",
  REJECTED: "declined"
};

const NODETAILS = -1;

// initial state
const init = () => {
  return {
    filters: [],
    stretches: [],
    imports: [],
    staging: [],
    reviewed: [],
    importToReview: null,
    stagingVisible: true,
    logsVisible: true,
    show: NODETAILS,
    showAdditional: NODETAILS,
    showLogs: NODETAILS
  };
};

const getStretchFromWFS = filter => {
  return new Promise((resolve, reject) => {
    var stretchesFeatureCollectionRequest = new WFS().writeGetFeature({
      srsName: "EPSG:4326",
      featureNS: "gemma",
      featurePrefix: "gemma",
      featureTypes: ["stretches_geoserver"],
      outputFormat: "application/json",
      filter: filter
    });
    HTTP.post(
      "/internal/wfs",
      new XMLSerializer().serializeToString(stretchesFeatureCollectionRequest),
      {
        headers: {
          "X-Gemma-Auth": localStorage.getItem("token"),
          "Content-type": "text/xml; charset=UTF-8"
        }
      }
    )
      .then(response => {
        resolve(response);
      })
      .catch(error => {
        reject(error);
      });
  });
};

const imports = {
  init,
  namespaced: true,
  state: init(),
  getters: {
    processedReviews: state => {
      return state.staging
        .filter(x => x.status !== STATES.NEEDSAPPROVAL)
        .map(r => {
          return {
            id: r.id,
            state: r.status
          };
        });
    }
  },
  mutations: {
    setFilters: (state, filters) => {
      state.filters = filters;
    },
    clearFilters: state => {
      state.filters = [];
    },
    setStretches: (state, stretches) => {
      state.stretches = stretches;
    },
    setReviewed: (state, reviewed) => {
      state.reviewed = reviewed;
    },
    setImports: (state, imports) => {
      const lookUp = state.reviewed.reduce((o, n) => {
        const { id, status } = n;
        o[id] = status;
        return o;
      }, {});
      imports = imports.map(x => {
        if (x.state === "pending") {
          const reviewState = lookUp[x.id];
          if (reviewState) {
            x.status = reviewState;
          } else {
            x.status = STATES.NEEDSAPPROVAL;
          }
        }
        return x;
      });
      state.imports = imports;
    },
    setStagingVisibility: (state, visibility) => {
      state.stagingVisible = visibility;
    },
    setLogsVisibility: (state, visibility) => {
      state.logsVisible = visibility;
    },
    setStaging: (state, staging) => {
      const enriched = staging.map(x => {
        return { ...x, status: STATES.NEEDSAPPROVAL };
      });
      state.staging = enriched;
    },
    showDetailsFor: (state, id) => {
      state.show = id;
    },
    hideDetails: state => {
      state.show = NODETAILS;
    },
    showAdditionalInfoFor: (state, id) => {
      state.showAdditional = id;
    },
    hideAdditionalInfo: state => {
      state.showAdditional = NODETAILS;
    },
    showAdditionalLogsFor: (state, id) => {
      state.showLogs = id;
    },
    hideAdditionalLogs: state => {
      state.showLogs = NODETAILS;
    },
    setImportToReview: (state, id) => {
      if (!isNaN(parseFloat(id)) && isFinite(id)) {
        state.importToReview = id;
      }
    },
    toggleApprove: (state, change) => {
      const { id, newStatus } = change;
      const stagedResult = state.imports.find(e => {
        return e.id === id;
      });
      if (stagedResult.status === newStatus) {
        stagedResult.status = STATES.NEEDSAPPROVAL;
        state.reviewed = state.reviewed.filter(x => x.id !== stagedResult.id);
      } else {
        stagedResult.status = newStatus;
        let index = state.reviewed.findIndex(r => r.id === id);
        if (index !== -1) {
          state.reviewed[index].status = newStatus;
        } else {
          state.reviewed.push({ id: stagedResult.id, status: newStatus });
        }
      }
    },
    toggleApproval: (state, change) => {
      const { id, newStatus } = change;
      const stagedResult = state.staging.find(e => {
        return e.id === id;
      });
      if (stagedResult.status === newStatus) {
        stagedResult.status = STATES.NEEDSAPPROVAL;
      } else {
        stagedResult.status = newStatus;
      }
    }
  },
  actions: {
    loadStretch({ commit }, name) {
      return new Promise((resolve, reject) => {
        getStretchFromWFS(equalToFilter("name", name))
          .then(response => {
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    loadStretches({ commit }) {
      return new Promise((resolve, reject) => {
        getStretchFromWFS(equalToFilter("staging_done", true))
          .then(response => {
            if (response.data.features) {
              commit("setStretches", response.data.features);
            } else {
              commit("setStretches", []);
            }
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    saveStretch({ commit }, stretch) {
      return new Promise((resolve, reject) => {
        HTTP.post("/imports/st", stretch, {
          headers: { "X-Gemma-Auth": localStorage.getItem("token") }
        })
          .then(response => {
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    getImports({ commit }, filter) {
      let queryParams = "";
      if (filter && filter.length > 0)
        queryParams = "?states=" + filter.join(",");
      return new Promise((resolve, reject) => {
        HTTP.get("/imports" + queryParams, {
          headers: { "X-Gemma-Auth": localStorage.getItem("token") }
        })
          .then(response => {
            const { imports } = response.data;
            commit("setImports", imports);
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    getStaging({ commit }) {
      return new Promise((resolve, reject) => {
        HTTP.get("/imports?states=pending", {
          headers: { "X-Gemma-Auth": localStorage.getItem("token") }
        })
          .then(response => {
            commit("setStaging", response.data.imports);
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    },
    confirmReview({ state }, reviewResults) {
      return new Promise((resolve, reject) => {
        HTTP.patch("/imports", reviewResults, {
          headers: {
            "X-Gemma-Auth": localStorage.getItem("token"),
            "Content-type": "application/json"
          }
        })
          .then(response => {
            resolve(response);
          })
          .catch(error => {
            reject(error);
          });
      });
    }
  }
};

export { imports, STATES };