import fs from 'fs'
import http from 'http'
import path from 'path'
import express from 'express'
import fetch from 'node-fetch'
import cron from 'cron'
import {TableInterface, QueueInterface} from "./AzureModule.js"
import {DBData} from "./DBDataModule.js"
import {JiraTools} from "./JiraModule.js"

var app = express();
const tableClient = new TableInterface("NAUTableStorage");
const queueClient = new QueueInterface("versa-test-status");
const jiraClient = new JiraTools("wdcapstonetest", "VG");
const port = process.env.PORT || 80;
const __dirname = path.resolve();

let vms = new DBData(
  {
    "version": "2.4",
    "system": "NA",
    "vm":"wi11",
    "type": "NA",
    "start": "NA",
    "vmlink": "NA",
    "vmstatus":"NA",
    "owner":"NA",
    "ownerID": "NA",
    "vmlocation":"NA",
    "vmversion":"NA",
    "testingDesc": "NA",
    "capabilities" : "NA",
    "currentTest" : "NA",
    "product" : "NA",
    "fw" : "NA"
  },
    "NAUTableStorage", "VM", "vm", 2.4);
let fws = new DBData(
  {
    "version": "2.0",
    "product":"NA",
    "status":"NA",
    "fwversion":"NA",
    "fwlink": "NA", // ffu link
    "commitid":"NA",
    "form":"NA",
    "fwlocation":"NA",
    "serial":128648
  },
    "NAUTableStorage", "FW", "serial", 2.0);
let issues = new DBData(
  {
    "version": "2.1",
    "id":"VG-11",
    "status":"NA",
    "closed": "NA",
    "desc": "NA",
    "link": "NA",
    "vm": "NA", // vm row key
    "fw": "NA" // fw row key
  },
    "NAUTableStorage", "FWIssues", "id", 2.1);
let systems = new DBData(
  {
    "version": 2.1,
    "location": "NA",
    "id": "VICE2",
    "schedule": "NA",
    "vms": "NA",
    "DUTs": "NA"
  },
    "NAUTableStorage", "System", "id", 2.0);
let wrkRequests = new DBData(
  {
    "version": 2.0,
    "id": 1234987,
    "desc": "NA",
    "system": "NA"

  },
    "NAUTableStorage", "ExeIssues", "id", 2.0);

let users = new DBData(
  {
    "id": "emailhash",
    "pass": "NA",
    "role": "NA",
    "auth": "NA",
    "Name": "NA"
  },
    "NAUTableStorage", "User", "id", 1.0);

app.all("/*", function(req, res, next){
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE,OPTIONS');
  res.header('Access-Control-Allow-Headers',
             "Content-Type, Authorization, Content-Length, X-Requested-With,  \
              issueID, SystemID, status");
  next();
});

app.use(
  express.urlencoded({
    extended: true
  }),
  express.json(),
  express.static('express')
);


var RootRequestHandler = async function(request, response) {
  response.sendFile("./express/index.html", {root: __dirname});
}

var VMRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(typeof authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  console.log(authData);
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }


  let vmrequest = await vms.getDbData();
  if(vmrequest.result === "Success") {
    response.send(vmrequest.data);
  }
  else {
    console.log("Failed");
    response.send(["No VMs"]);
  }
}

var FWRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }

  let fwrequest = await fws.getDbData();

  if(fwrequest.result === "Success") {
    response.send(fwrequest.data);
  }
  else {
    console.log("Failed");
    response.send(["No FWs"]);
  }
}

var IssueRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }

  var issuesData = await issues.getDbData();
  var activeIssues = [];

  for(const issue of issuesData.data) {
    if(issue.status !== 'Done')
    {
      activeIssues.push(issue);
    }
  }

  //console.log("got issues: " + issues);

  response.send(activeIssues);

};

var WorkRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }

  var worksRequest = await wrkRequests.getDbData();
  var works = [];

  for(let work of worksRequest.data) {
    if(work.partitionKey === "ExeIssues") {
      works.push(work);
    }
  }

  response.send(works);
}

var IssueDataRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }


  var data = {
    id: 404,
    desc: "Data not found",
    link: "N/A",
    vmdata: {
      vm:"404",
      vmlinkWin: "",
      vmlinkLin: "",
      vmstatus:"",
      owner:"",
      vmlocation:"",
      vmversion:""
    },
    fwdata: {
      product: "",
      status:"",
      fwversion:"",
      fwlink: "",
      commitid:404,
      form:"",
      fwlocation:"",
      serial:404
    }
  };

  let issueID = request.headers.issueid;
  console.log(issueID);
  let issueData = await issues.getDbData(issueID);

  if(issueData.result == "Success") {
    issueData = issueData.data;
    //console.log(issueData);

    let vmData = await vms.getDbData(issueData.vm);
    let fwData = await fws.getDbData(issueData.fw);
    //console.log(vmData.result, fwData.result);

    if(vmData.result == "Success" && fwData.result == "Success") {
      vmData = vmData.data;
      fwData = fwData.data;
      //console.log(vmData);
      //console.log(fwData);

      data = {
        id: issueData.id,
        desc: issueData.desc,
        link: issueData.link,
        vmdata: vmData,
        fwdata: fwData
      }

      console.log(data);
    }

    response.send(data);
  }
  else {
    response.send(data);
  }



}

var IssueStatusChangeHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }

  let issueID = request.headers.issueid;
  let status = request.headers.status;
  let date = Date.now();

  let result = await jiraClient.set_issue_status(issueID, status);
  console.log(result);

  // change status in DB
  issues.updateDbData(issueID, {status: status, closed: date});

  // send done response
  response.send({result: "done"});
}

var WorkResolveHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }

  let issueID = request.headers.issueid;
  console.log(issueID);

  // change status in DB
  let result = await wrkRequests.deleteDbData(issueID);
  console.log(result);

  // send done response
  response.send({result: "done"});
}

var SystemsRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }


  let systemData = await systems.getDbData();

  if(systemData.result === "Success") {
    response.send(systemData.data);
  }
  else {
    console.log("Failed");
    response.send(["No Systems"]);
  }
}

var AddReservationRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  let data = request.body;
  let system = data.system;
  let reservation = data.res;
  console.log(data);

  let systemData = await systems.getDbData(system);
  // console.log(systemData);
  let schedule = JSON.parse(systemData.data.schedule);
  let newSchedule = [];
  let startDate = (new Date(reservation.start)).getTime();
  let endDate = (new Date(reservation.end)).getTime();
  let resStart = {};
  let resEnd = {};

  for(let res of schedule) {
    if(res.vm == reservation.vm) {
      resStart = (new Date(res.start)).getTime();
      resEnd = (new Date(res.end)).getTime();
      if(((startDate >= resStart && startDate <= resEnd) ||
          (endDate >= resStart && endDate <= resEnd) ||
          (resStart >= startDate && resStart <= endDate) ||
          (resEnd >= startDate && resEnd <= endDate))) {

        console.log("Conflict\nnew res: " + startDate + "-" + endDate + "\n\
        old res: " + resStart + "-" + resEnd);
      }
      else {
        newSchedule.push(res);
      }
    }
    else {
      newSchedule.push(res);
    }
  }
  newSchedule.push(reservation);

  schedule = JSON.stringify(newSchedule);
  let result = await systems.updateDbData(system, {schedule: schedule});
  return result;

  /*let result = await tableClient.addReservation(data.system, data.res);

  console.log(result);

  if(result.result == "Success") {
    response.send({result: "Success", data: result});
  }
  else {
    response.send({result: "Failed", data: result});
  }
  */
}

var AddWorkRequestHandler = async function(request, response) {
  let authData = request.headers.authorization;
  if(authData === undefined) {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }
  authData = authData.split(' ');
  let auth = await authenticateUser(authData[0], authData[1]);
  if(auth.result === "Failed") {
    response.send({result: "Failed", data: "Non-authorized user"});
    return;
  }

  let data = request.body;
  let work = {version: 2.0, ...data};
  console.log(work);

  let result = await wrkRequests.addDbData(work);

  console.log(result);

  if(result.result == "Success") {
    response.send({result: "Success", data: result});
  }
  else {
    response.send({result: "Failed", data: result});
  }
}

var AuthenticateRequestHandler = async function(request, response) {
  let userID = request.body.emailhash;
  let pwHash = request.body.pwhash
  console.log(userID);

  let result = await authenticateUser(userID, pwHash);

  response.send(result);
}

app.get("/", RootRequestHandler);
app.get("/issue", IssueRequestHandler);
app.get("/issueData", IssueDataRequestHandler);
app.get("/systems", SystemsRequestHandler);
app.get("/vm", VMRequestHandler);
app.get("/fw", FWRequestHandler);
app.get("/works", WorkRequestHandler);
app.get("/changeStatus", IssueStatusChangeHandler);
app.get("/resolveWorkRq", WorkResolveHandler);
app.get("/*", RootRequestHandler);

app.post("/addRes", AddReservationRequestHandler);
app.post("/addWork", AddWorkRequestHandler);
app.post("/authenticate", AuthenticateRequestHandler);

app.listen(port);

console.log("\nServer started on port " + port + "\n");


/*
This function currently assigns random data, but once actual data is attached,
just modify function to get the correct data from the jira issue. If jira issue
does not have all the values, insert placeholders to indicate so
*/
let updateDBIssues = new cron.CronJob('00 00,10,20,30,40,50 * * * *' , async () => {
  const vms = ["la", "sf", "wi", "az"];;
  const vmstatus = ["In-Progress", "Completed", "Idle"];
  const names = ["John Deer", "Becky Bowler", "Lil John", "Hollow Knight", "Derik Sonder"];
  const locations = ["San Francisco", "Madison", "Phoenix", "Austin"];
  const vmversions = ["Linux", "Windows", "MacOS"];
  const products = ["WD Blue", "WD Black", "WD Yellow", "WD Cyan", "WD Red"];
  const status = ["Passing", "Failing", "Passed", "Failed"];
  const fwversions = ["0.0.9", "1.6.9", "4.2.0", "2.3.2", "18.3.4"];
  const forms = ["M.2", "7.5in", "2ft"];
  const serials = [603735, 919120, 411894, 598273, 430917, 299357, 329593];

  var issueData = {};

  console.log("Updating issues in database...");

  jiraClient.get_all_issues().then( async (jiraIssues) => {

    for (const issue of jiraIssues) {
      let issueID = issue.id;
      let description = issue.description;

      issueData = {
      version: 2.1,
      id: issueID,
      desc: description,
      link: "Placeholder",
      status: issue.status,
      closed: issue.closed || "NA",
      vm: vms[Math.floor(Math.random() * vms.length)] + Math.floor(Math.random() * 10),
      fw: serials[Math.floor(Math.random() * serials.length)]
      };

      issues.addDbData(issueData);
    }
  });

});


let checkQueue = new cron.CronJob('00 00,10,20,30,40,50 * * * *', async () => {
  // vars
  let messages = {};
  let currentMessage = null;
  let status = "";
  let vm = "";
  let test = "";

  console.log("checking queue... \n");

  // check queue for messages
  messages = await queueClient.checkMessages();

  // if there are messages
  if(messages.headMessages.length > 0) {
    console.log("messages found, updating data...");
    // while there are messages
    currentMessage = await queueClient.getNextMessage();
    while(currentMessage != null) {
      // seperate message pieces
      currentMessage = currentMessage.split(':');
      vm = currentMessage[0];
      status = currentMessage[1];
      test = currentMessage[2];

      // update vm currentTest
      tableClient.modData(1, vm, 1, "", {currentTest: test, vmstatus: status});

      currentMessage = await queueClient.getNextMessage();
    // end loop
    }
  }

});

let clearOldReservations = new cron.CronJob('00 00 23 * * *', async () => {
  let systems = await tableClient.getAllSystems();

  for(let system of systems.data) {
    tableClient.removeOldReservations(system);
  }

});

let authenticateUser = async function(email, pw) {
  let result = await users.getDbData(email);

  if(result.result === "Success") {
    if(result.data.pw == pw) {
      return result;
    }
    else {
      return {result: "Failed", auth: 0, role: 0};
    }
  }
  else {
    return {result: "Failed", auth: 0, role: 0};
  }
}



clearOldReservations.start();
updateDBIssues.start();
checkQueue.start();