import { HttpClient } from '@angular/common/http';
import { Injectable } from '@angular/core';
import { AppConf } from '../app-conf/app-conf';
import { AppUtil } from '../app-util/app-util';
import { DbSvc } from '../db/db';
import { RemoteService } from '../remote/remote';

@Injectable()
export class DataSync {

  constructor(public http: HttpClient, public appConf: AppConf, public appUtil: AppUtil, public db: DbSvc,
    public remoteService: RemoteService) {
  }

  public Synced = "C";
  public Syncing = "I";
  public SyncFailed = "F";

  public pullData(TableList, batchNo, chunkNo) {
    // tableList Shuld be like below 
    // "TableList": [{"Table": "X_Student"}]
    let promise = new Promise((resolve, reject) => {
      let actualDat = {
        AppInstanceUU: this.appConf.getAppInstance(),
        TableList: TableList,
        BatchNo: batchNo,
        ChunkNo: chunkNo
      };

      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "PullData",
            "ParamValues": {
              "field": [{
                "@column": "PullRequestJson",
                "val": this.appUtil.encodeJsonTOBase64(actualDat)
              }]
            }
          }
        }
      };

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

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let error = response["@IsError"];
        let res = {
          Error: ''
        };
        if (error == "true") {
          console.error("DataSync -> self.pullData() -> RemoteService.invokeRemoteAction() -> Error in response");
          res.Error = response['Error'];
        } else {
          let jObject = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (jObject.Error) {
            console.error("DataSync -> self.pullData() -> RemoteService.invokeRemoteAction() -> Error in response");
            res.Error = jObject.Error;
          } else {
            if (jObject.Data.length > 0) {
              this.ongetPullData(jObject.Data, jObject.TotalRecords).then((res) => {
                return this.pullData(TableList, jObject.BatchNo, jObject.ChunkNo);
              }, (res) => {
                reject(res);
              });
            } else {
              resolve(res);
            }
          }
        }
        if (res.Error) {
          reject(res);
        }
      });
    });

    return promise;
  };

  public ongetPullData(data, TotalRecords) {
    /* 
    $rootScope.$broadcast('LoadingCounter', {
      Data: data,
      TotalRecord: TotalRecords
    }); 
    */
    let defList = [];
    data.forEach(value => {
      if (value.Table) {
        let prom = new Promise((resolve, reject) => {
          this.updateLocalData(value.Table, value.Rows).then((res) => {
            resolve(res);
          }, (res) => {
            reject(res);
          });
        });
        defList.push(prom);
      }
    });

    return Promise.all(defList);
  }

  public updateLocalData(tablename, DataRows) {
    let tableKey = tablename + '_uu';
    let defList = [];
    DataRows.forEach(row => {
      if (row.hasOwnProperty(tableKey) && row[tableKey]) {
        let prom = new Promise((resolve, reject) => {
          let len = Object.keys(row).length;
          if (len == 1) {
            this.db.removeRecordByTableID(tablename, row[tableKey]).then((res) => {
              resolve(res);
            }, (res) => {
              reject(res);
            });
          } else {
            this.insertOrUpdateData(tablename, row).then((res) => {
              resolve(res);
            }, (res) => {
              reject(res);
            });
          }
        });
        defList.push(prom);
      }
    });
    return Promise.all(defList);
  }

  public insertOrUpdateData(tablename, row) {
    let tableKey = tablename + '_uu';
    let promise = new Promise((resolve, reject) => {
      this.db.isDataExist(tablename, row[tableKey]).then((val) => {
        if (val == true) {
          this.db.updateTableRow(tablename, row).then((res) => {
            resolve(res);
          }, (res) => {
            reject(res);
          });
        } else {
          this.db.addTableRow(tablename, row, true).then((res) => {   //need to add true as param
            resolve(res);
          }, (res) => {
            reject(res);
          });
        }
      });
    })
    return promise;
  }

  public pushData(Data) {
    // Data Shuld be like below 
    // [{"Table": "X_Student", "Rows" : [{"name": "","value": ""}]}]

    // delete app_synced and app_updated columns from sync data

    let promise = new Promise((resolve, reject) => {
      for (let i = 0; i < Data.length; i++) {
        let row = Data[i].Rows;
        for (let j = 0; j < row.length; j++) {
          let keys = Object.keys(row[j]);
          for (let k = 0; k < keys.length; k++) {
            let key = keys[k];
            if (key.toLowerCase() == 'app_synced' || key.toLowerCase() == 'app_updated') {
              delete Data[i].Rows[j][key];
            } else {
              if (key.toLowerCase() != key && (key.toLowerCase() == Data[i].Table.toLowerCase() + "_uu")) {
                Data[i].Rows[j][key.toLowerCase()] = Data[i].Rows[j][key];
                delete Data[i].Rows[j][key];
              }
            }
          }
        }
      }
      let actualDat = {
        AppInstanceUU: this.appConf.getAppInstance(),
        Data: Data
      };

      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "PushData",
            "ParamValues": {
              "field": [{
                "@column": "PushRequestJson",
                "val": this.appUtil.encodeJsonTOBase64(actualDat)
              }]
            }
          }
        }
      };

      let request = {
        method: "POST",
        actionType: "/run_process"
      };
      let syncInitTime = Date.now();
      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let error = response["@IsError"];
        let res = {
          Error: ''
        };
        if (error == "true") {
          console.error("DataSync -> self.pushData() -> RemoteService.invokeRemoteAction() -> Error in response");
          res.Error = response['Error'];
          let x = 1;
          if (x === 1) {
            x = 0;
            this.appUtil.popUp(response['Error'], "TokenExpire", "Login", "Ignore").then((ok) => {
              this.appConf.removeLoginParam();
              //$state.go("appLogin");
            }, (cancel) => {
              console.error("DataSync -> self.pushData() -> RemoteService.invokeRemoteAction() -> Skipped the Authentication");
            });
          }
        } else {
          let jObject = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (jObject.Error) {
            console.error("DataSync -> self.pushData() -> RemoteService.invokeRemoteAction() -> Error in response");
            res.Error = jObject.Error;
          } else {
            if (jObject.Data.length > 0) {
              let errorList = this.parseError(jObject.Data);
              if (errorList.length > 0) {
                console.error("DataSync -> self.pushData() -> RemoteService.invokeRemoteAction() -> Error in response");
                //res.Error = errorList; //"Some Data not synced proper";
              } else {
                // Generic Logic for update all updated rows with Sync initial timings
                for (let i = 0; i < jObject.Data.length; i++) {
                  let data = jObject.Data[i];
                  if (this.appUtil.isNotNull(data)) {
                    let tableName = data.Table;
                    for (let j = 0; j < data.Rows.length; j++) {
                      let row = data.Rows[j];
                      if (row.Status == 'Success') {
                        let sql = "Update " + tableName + " SET app_synced = '" + syncInitTime +
                          "' WHERE " + tableName.toLowerCase() + "_uu = ? ";
                        this.db.query(sql, [row.UU]).then((response) => {
                          console.info("DataSync -> self.pushData () -> Synced time updated for Table:" + tableName + " - UU:" + row.UU);
                        }, (rejection) => {
                          console.error("DataSync -> self.pushData() -> Synced time not update for Table:" + tableName + "- UU:" + row.UU);
                        });
                      }
                    }
                  }
                }
                resolve(jObject);
              }
            } else {
              resolve(response);
            }
          }
        }
        if (res.Error) {
          reject(res);
        }
      });
    });


    return promise;
  };

  public parseError(jsonObj) {
    let errorLis = [];
    let type = typeof jsonObj;
    if (type == "object") {
      for (let key in jsonObj) {
        if (key == "Error") {
          errorLis.push(jsonObj);
        } else {
          //angular.merge(errorLis, self.parseError(jsonObj[key]));
        }
      }
    } else {
      // Do something with data
    }
    return errorLis;
  }

  public attachData(Data) {
    // Data Shuld be like below 
    // "Data": [ { "Table": "","Rows": [{"UU": "","AlwaysAdd": "Y","Attachments": [{"Content": "",
    // "FileName": "letTest.text" } ] } ] } ]

    let promise = new Promise((resolve, reject) => {
      let actualDat = {
        AppInstanceUU: this.appConf.getAppInstance(),
        Data: []
      };

      if (Data instanceof Object && Data instanceof Array) {
        actualDat.Data = Data;
        //angular.merge(actualDat.Data, Data); //when Object
      } else if (Data instanceof Object) {
        actualDat.Data.push(Data); //when Array
      } else {
        actualDat.Data = Data;
        //angular.merge(actualDat.Data, Data); //default
      }

      let data = {
        "ModelRunProcessRequest": {
          "ModelRunProcess": {
            "serviceType": "SyncAttachment",
            "ParamValues": {
              "field": [{
                "@column": "AttachmentJson",
                "val": this.appUtil.encodeJsonTOBase64(actualDat)
              }]
            }
          }
        }
      };

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

      this.remoteService.invokeRemoteAction(request, data).then((response) => {
        let error = response["@IsError"];
        let res = {
          Error: ''
        };
        if (error == "true") {
          console.error("DataSync -> self.attachData() -> Error: " + response['Error']);
          res.Error = response['Error'];
          let x = 1;
          if (x === 1) {
            x = 0;
            this.appUtil.popUp(response['Error'], "TokenExpire", "Login", "Ignore").then((ok) => {
              this.appConf.removeLoginParam();
              // this.appConf.setLSItems('driverappSync', null);    //as for committed
              // this.appConf.setLSItems('VehicleTestSkip', null);
              //$state.go("appLogin");
            }, (cancel) => {
              console.error("DataSync -> self.attachData() -> Error : ");
            });
          }
        } else {
          let jObject = this.appUtil.decodeBase64ToJson(response['Summary']);
          if (jObject.Error) {
            console.error("DataSync -> self.attachData() -> Error on Object :");
          } else {
            if (jObject.Data.length > 0) {
              resolve(jObject);
            } else {
              resolve(res); //TODO: Have to  put the Reject
            }
          }
        }
        if (res.Error) {
          reject(res);
        }
      });
    });
    return promise;
  };
}