import { Injectable } from '@angular/core';
import { AppConf } from '../app-conf/app-conf'
import { DbSvc } from '../db/db';
import { Migration } from '../migration/migration';
import { RemoteService } from '../remote/remote';
import { AppUtil } from '../app-util/app-util';
import { AD_SysConfig } from '../setting/setting';
import { MigrationSql } from '../migration-sql/migration-sql';
import { FileSvc } from '../file/file-service';

@Injectable()
export class AppInit {

  constructor(public remoteService: RemoteService, public migration: Migration,
    public dbSvc: DbSvc, public appConf: AppConf, public appUtil: AppUtil, public adSysConfig: AD_SysConfig,
    public migrationSQL: MigrationSql, public fileSvc: FileSvc) {

  }

  public init() {
    var me = this;
    console.info("AppInit -> AppIntialization Start");
    me.appConf.init().then((res) => {
      console.info("AppInit -> AppConf Intialization Done.");
      me.dbSvc.init().then((res) => {
        console.info("AppInit -> DBSvc Intialization Done.");
        me.adSysConfig.init().then((response) => {
          console.info("AppInit -> AD_SysConfig Intialization Done.");
          me.migration.init().then((response) => {
            console.info("AppInit -> AppMigration Intialization Done.");
            me.migrationSQL.init().then((response) => {
              console.info("AppInit -> AppMigrationSQL Intialization Done.");
              me.fileSvc.init();
            }, (reject) => {
              console.error("AppInit -> self.init() -> ERROR: AppMigrationSQL.init()");
            });
          }, (reject) => {
            console.error("AppInit -> self.init() -> ERROR: AppMigration.init()");
          });
        }, (reject) => {
          console.error("AppInit -> self.init() -> ERROR: AD_SysConfig.init()");
        });
      }, (err) => {
        console.error("AppInit -> self.init() -> ERROR: DBSvc.init()");
      });
    }, (err) => {
      console.error("AppInit -> self.init() -> ERROR: AppConf.init()");
    });
  };

  public needTosyncMigration() {
    if (this.appConf.getVersion() != this.appConf.getAppVersion())
      return false;
    return true;
  }

  public checkIsMigrationsqlComplete(res) {
    if (res.IsMore == "true" && JSON.parse(res.SeqNo) > 0 && JSON.parse(res.Version) > 0) {
      return false;
    } else if (res.IsMore == "false" && JSON.parse(res.Version) > 0) {
      return true;
    }
  }

  public clearAppSyncHistory() {

    let promise = new Promise((resolve, reject) => {
      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "ClearAppSyncHistory",
            "ParamValues": {
              "field": [{
                "@column": "AppName",
                "val": this.appConf.getAppName()
              }, {
                "@column": "IMEI",
                "val": this.appConf.getIMEI()
              }]
            }
          }
        }
      }

      let request = {
        method: "POST",
        actionType: "/run_process"
      }

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let res = {
          error: ''
        };
        let error = response["@IsError"];
        if (error == "true") {
          console.error("Error : " + response['Error']);
          //AppUtil.alert(response.Error);
          res.error = response['Error'];

        } else {
          let obj = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (obj.Error) {
            alert(obj.Error);
          } else {
            console.info("Sync History Cleared SuccessFully");
          }
        }

        if (res.error) {
          reject(res);
        } else {
          resolve(res);
        }
      }, (reject) => {
        reject(reject);
      });
    });

    return promise;
  }

  public getAppInstance() {

    let promise = new Promise((resolve, reject) => {
      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "GetAppInstance",
            "ParamValues": {
              "field": [{
                "@column": "AppName",
                "val": this.appConf.getAppName()
              }, {
                "@column": "IMEI",
                "val": this.appConf.getIMEI()
              }
              ]
            }
          }
        }
      }

      let request = {
        method: "POST",
        actionType: "/run_process"
      };

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let res = {
          error: ''
        };
        let error = response["@IsError"];
        if (error == "true") {
          //AppUtil.alert(response.Error);
          //res.error = response.Error;

        } else {
          let obj = this.appUtil.decodeBase64ToJson(response['Summary']);
          console.log(obj);
          if (obj.Error) {
            alert(obj.Error);
          } else {
            this.appConf.setAppInstance(obj.AppInstanceUU);
          }
        }

        if (res.error) {
          reject(res);
        } else {
          resolve(res);
        }
      });
    });

    return promise;
  };

  public syncSysConfigData() {
    let promise = new Promise((resolve, reject) => {
      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "GetSysConfig",
            "ParamValues": {
              "field": [{
                "@column": "AppInstanceUU",
                "val": this.appConf.getAppInstance()
              }]
            }
          }
        }
      };

      let request = {
        method: "POST",
        actionType: "/run_process"
      };

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let res = {
          error: ''
        };

        let error = response["@IsError"];
        if (error == "true") {
          //AppUtil.alert(response.Error);
          //res.error = response.Error;
        } else {
          let jObject = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (jObject.Error) {
            alert(jObject.Error);
          } else {

            jObject.Data[0].Rows.forEach(obj => {
              // AD_SysConfig.addArray([obj]); TODO: Add to the 
            });
          }
        }
        if (res['Error']) {
          reject(res);
        } else {
          this.syncMigrationData().then((res) => {
            resolve(res);
          }, (rej) => {
            reject(rej);
          });
        }
      });
    });
    return promise;
  }

  public syncMigrationData() {
    let promise = new Promise((resolve, reject) => {
      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "GetAppMigration",
            "ParamValues": {
              "field": [{
                "@column": "AppInstanceUU",
                "val": this.appConf.getAppInstance()
              }, {
                "@column": "BaseVersion",
                "val": this.appConf.getVersion()
              }, {
                "@column": "CurrentVersion",
                "val": this.appConf.getAppVersion()
              }, {
                "@column": "IsBeta",
                "val": this.appConf.isBeta()
              }]
            }
          }
        }
      };

      let request = {
        method: "POST",
        actionType: "/run_process"
      };

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let res = {
          error: ''
        };
        let migrations = [];
        let error = response["@IsError"];
        if (error == "true") {
          alert(response['Error']);
          res.error = response['Error'];
        } else {
          let jObject = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (jObject.Error) {
            alert(jObject.Error);
          } else {
            if (jObject.Data.length > 0) {
              if (jObject.Data[0].Rows) {
                //AppMigration.addArray(jObject.Data[0].Rows);
                //angular.extend(migrations, jObject.Data[0].Rows)
              }
            }
          }
        }

        if (res['Error']) {
          reject(res);
        } else {
          let loopPromises = [];
          migrations.forEach(obj => {

            let prom = new Promise((resolve, reject) => {
              this.syncMigrationSqlData(0, obj.version).then((res) => {
                resolve(res);
              }, (res) => {
                reject();
              });
            });
            loopPromises.push(prom);
          });

          Promise.all(loopPromises).then((res) => {
            resolve(res);
          }, (res) => {
            reject(res);
          });
        }
      });
    });

    return promise;
  }

  public syncMigrationSqlData(seqNo, version) {
    let promise = new Promise((resolve, reject) => {
      if (!seqNo)
        seqNo = null;
      if (!version)
        version = null;
      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "GetMigrationSQL",
            "ParamValues": {
              "field": [{
                "@column": "AppInstanceUU",
                "val": this.appConf.getAppInstance()
              }, {
                "@column": "SeqNo",
                "val": seqNo
              }, {
                "@column": "Version",
                "val": version
              }]
            }
          }
        }
      };

      let request = {
        method: "POST",
        actionType: "/run_process"
      };

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let error = response["@IsError"];
        let res = {
          Error: ''
        };
        if (error == "true") {
          alert(response['Error']);
          res.Error = response['Error'];
        } else {
          let jObject = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (jObject.Error) {
            res.Error = response['Error'];
            reject(res);

          } else {
            if (jObject.Data.length > 0) {
              if (jObject.Data[0].Rows) {
                /* AppMigrationSQL.addArray(jObject.Data[0].Rows).then((res) => {
                  if (this.checkIsMigrationsqlComplete(jObject)) {
                    return AppMigrationSQL.applySQLByVersion(jObject.Version, deferred);
                  } else {
                    this.syncMigrationSqlData(jObject.SeqNo, jObject.Version);
                  }
                }); */
              }
            }
          }
        }
      });
    })
    return promise;
  }
}