import { ManaPlusApp } from './manaApp/manaApp.interface';
import { ManaPlusAppWindows } from './manaApp/windows';
import * as os from 'os';
import * as path from 'path';
import * as fs from 'fs-extra';
import { app, ipcMain, shell, dialog } from 'electron';
import { Status, EventEmitter } from '../status';
import { ManaPlusAppLinux } from './manaApp/linux';

let ManaPlusInstance:ManaPlusApp;

let CurrentServer:{serverID:string,address:string}=null;

export namespace ManaPlus{

  export const ERRORS = {
    NOT_INITILIZED_YET_ERROR:new Error("The ManaPlus updater wasn't initilized")
  }

  export function init(){
    if(os.platform() == "win32"){
      ManaPlusInstance = new ManaPlusAppWindows();
      console.log("GameDir:"+ManaPlusInstance.getGameDir());
    }

    if(os.platform() == "linux"){
      ManaPlusInstance = new ManaPlusAppLinux();
      console.log("startCommand:"+ManaPlusInstance.startCommand);
    }
  }

  export async function update(){
    if(!wasInitilized())throw ERRORS.NOT_INITILIZED_YET_ERROR;

    return await ManaPlusInstance.update();
  }



  export async function start(args: any){
    CurrentServer={
      serverID:args.serverID,
      address:args.address
    };
    let params:string[];
    try {
      params = await makeParams(args.address,args.port,args.engine,args.username,args.password);
      //params = ['-v'];// DEBUG: This option is to disable manaplus for testing (open it just for getting the version)
    } catch (e){
      console.log(e);
      Status.showError("Launch Preperation Failed (LPF_PARMS)", e.message, "Launch preparation failed");
      Status.setPlaying(false);
      return;
    }
    let willUpdate:boolean=false;
    // check if it is installed
    if(ManaPlusInstance.isInstalled()){
      // Check if update is available and ask if the user wants to update
      try {
        let version = await ManaPlusInstance.updateAvailable();
        willUpdate = (version.isNewVersion && await updateDialog(version.newestVersion));
      } catch (e){
        console.log(e);
        Status.showError("Launch Preperation Failed (LPF_Update): This error can also mean that you are offline, \
please check you network connection first.", e.message, "Launch preparation failed")
        Status.setPlaying(false);
        return;
      }
    } else {
      // Not installed will install it
      willUpdate = true;
    }
    // Install/Update the gameclient if needed
    if(willUpdate){
      try {
        await update();
      } catch (error) {
        Status.setPlaying(false);
        throw error;
      }
      
    }

    //IDEA have client data updated here to, if needed


    // Run it
    Status.setGameRunning(true);
    EventEmitter.emit('closeWindow');
    EventEmitter.emit('openTray');
    await runManaProgram(params,ManaPlusInstance.startCommand,args.address);
    // On Close
    Status.setGameStatus({server: "Launcher"})
    Status.setGameRunning(false);
    Status.setPlaying(false);
    Status.removeActivity();
    EventEmitter.emit('reopenWindow');
    EventEmitter.emit('closeTray');
    CurrentServer=null;
  }

}

ipcMain.on('getScreenshots', (event:any, arg:string)=> {
  const screenshotsDir = path.normalize(app.getPath('userData')+`/screenshots/${arg}/`);
  fs.existsSync(screenshotsDir) || fs.mkdirSync(screenshotsDir);
    fs.readdir(screenshotsDir, (err, dir) => {
      let screenshots:string[]=[];
        for (var i = 0, path; path = dir[i]; i++) {
          screenshots.push(path);
        }
      event.sender.send('getScreenshots', {dir:screenshotsDir, screenshots:screenshots.reverse().slice(0, 24)});
    });
});

EventEmitter.on('Mana:openScreenshotDir', ()=>{
  shell.openItem(path.normalize(app.getPath('userData')+`/screenshots/${CurrentServer.address}/`));
});

function wasInitilized(){
  return typeof(ManaPlusInstance) !== "undefined" && typeof(ManaPlusInstance) !== "undefined";
}

async function makeParams(server: any,port: any,engine: any,username?: any,password?: any):Promise<string[]>{
    let parameters:string[] = [];
    if(server && engine && port && server != 'noServer'){
      parameters.push(...[
        "-s", server,
        "-y", engine,
        "-p", port
      ]);
      if(username && password){
        parameters.push(...[
          "-U", username,
          "-P", password
        ]);
      }
    }
    // Setup Paths and stuff
    const configDir = path.normalize(app.getPath('userData')+"/mana_config");
    const localDataDir = path.normalize(app.getPath('userData')+"/mana_local_data");
    const screenshotsDir = path.normalize(app.getPath('userData')+`/screenshots/${server}`);
    await fs.ensureDir(configDir);
    await fs.ensureDir(localDataDir);
    await fs.ensureDir(screenshotsDir);
    parameters.push(...[
      "-C", configDir,
      "-L", localDataDir,
      "--screenshot-dir", screenshotsDir,
    ]);
    //console.log(parameters);

    return parameters;
}

let manaplusInstance: any=null;

function runManaProgram(parameters: string[],gameExe:string,server?:string): Promise<any> {
  return new Promise(async(resolve, reject)=>{
    if(server){
      Status.setActivity(`Preparing Launch`);
      await setSkipUpdateWindows(server);
    }
    Status.setActivity(`Starting ManaPlus`);

    //console.log(gameExe, parameters);
    const child = require('child_process').execFile(gameExe, parameters, function(err:Error, data:any) {
         console.log(err);
         console.log(data.toString());
         Status.setActivity(`ManaPlus is running`);
    });
    child.on('close', ()=>{
      manaplusInstance = null;
      resolve();
    });
    child.on('error', ()=>{
      manaplusInstance = null;
      resolve();
      //// TODO: Handle Error
    });
    manaplusInstance = child;
  });
}

EventEmitter.on("Mana:killMana",()=>{
  if(manaplusInstance && manaplusInstance !== null)
    manaplusInstance.kill('SIGINT');
});

async function updateDialog(newestVersion:string):Promise<boolean>{
  const options = {
     type: 'info',
     title: `ManaPlus Update available: ${newestVersion}`,
     message: "Do you want to update now? Please note that you'll have to update eventually to ensure further compability with the servers",
     buttons: ['Nah, LATER', 'Update NOW']
   }
   let dialog = await dialogPromiseWrapper(options);
   console.log("....",dialog);
   return dialog === 1;
}

function dialogPromiseWrapper(options:any):Promise<number>{
  return new Promise((res, rej) => {
    dialog.showMessageBox(options, (index) => {
     res(index);
    })
  });
}

const default_server_config = '<?xml version="1.0"?>\
<configuration>\
 <option name="updateType" value="1"/>\
 <list name="player"/>\
</configuration>';
const parseString = require('xml2js').parseString, xml2js = require('xml2js');
async function setSkipUpdateWindows(server:string){
  const serverConfigXML = path.normalize(app.getPath('userData')+`/mana_config/${server}/config.xml`);

  if(fs.existsSync(serverConfigXML)){
    //add to this file
    try{
      let data = await fs.readFile(serverConfigXML, 'utf8');
      data = await editXML(data);
      await fs.outputFile(serverConfigXML, data);
    } catch (err){
      console.log(err);
    }

  }else{
    //create the file
    fs.outputFile(serverConfigXML, default_server_config);
  }

  return;
}

function editXML(xml:string):Promise<string>{
  return new Promise((res, rej)=>{
    parseString(xml, function(err:any, result:any){
        if(err) console.log(err);

        var json = result;
        const updaterVar = json.configuration.option.find((item:any)=>item.$.name=="updateType");
        if(updaterVar){
          if(updaterVar.$.value === 1){
            return rej(new Error("Has allready the right value"));
          }
          updaterVar.$.value = 1;
        }else{
          json.configuration.option.push({$:{name:"updateType",value:1}});
        }

        var builder = new xml2js.Builder();
        res(builder.buildObject(json));

    });
  });
}