// @ts-nocheck
import data_rdb from '@ohos.data.rdb';
import UIAbility from '@ohos.app.ability.UIAbility';
import { initCenterCache,initCenterCacheByKSPT,initEsModel,initialization } from '../../api/index'
import { dateFormat } from '../utils/tools';
import AccountTable from '../database/tables/AccountTable';
import MA_MARKRULE from '../constants/MA_MARKRULE';
import MA_SYSTEMPARM from '../constants/MA_SYSTEMPARM';
import MA_MAP_COLLECT from '../constants/MA_MAP_COLLECT';
import MA_MAP_COLLECT_SHAPE from '../constants/MA_MAP_COLLECT_SHAPE';
import MA_MAP_ITEMCLASS from '../constants/MA_MAP_ITEMCLASS';
import MA_MAP_POINT from '../constants/MA_MAP_POINT';
import MA_MAP_POINT_ITEM from '../constants/MA_MAP_POINT_ITEM';
import MA_MAP_ROAD from '../constants/MA_MAP_ROAD';
import MA_MAP_ROAD_LANE from '../constants/MA_MAP_ROAD_LANE';
import MA_MAP_SUBITEM from '../constants/MA_MAP_SUBITEM';
import MA_SYSSET from '../constants/MA_SYSSET';
import ES_CARINFO from '../constants/ES_CARINFO';
import ES_EXAMPOINTDETAIL from '../constants/ES_EXAMPOINTDETAIL';
import MA_MARKRULESET from '../constants/MA_MARKRULESET';
import MA_CDSBINFO from '../constants/MA_CDSBINFO';
import MA_ITEMINFO from '../constants/MA_ITEMINFO';
import MA_T_CARPARMSET from '../constants/MA_T_CARPARMSET';
import ES_CAR_VIDEO_PARAMETER from '../constants/ES_CAR_VIDEO_PARAMETER';
import IpConfigTable from '../constants/IpConfigTable';
import CommonConstants from '../constants/CommonConstants'
import DeviceInfoTable from '../constants/DeviceInfoTable'
import USER from '../constants/USER'
import util from '@ohos.util';
import zlib from '@ohos.zlib';
import FileModel from '../../pages/judgeSDK/utils/fileModel';
// @ts-nocheck
//读表
//参数平台
const map = {
  'MA_MARKRULE': MA_MARKRULE,
  'MA_SYSTEMPARM': MA_SYSTEMPARM,
  'MA_MAP_COLLECT': MA_MAP_COLLECT,
  'MA_MAP_COLLECT_SHAPE': MA_MAP_COLLECT_SHAPE,
  'MA_MAP_ITEMCLASS': MA_MAP_ITEMCLASS,
  'MA_MAP_POINT': MA_MAP_POINT,
  'MA_MAP_POINT_ITEM': MA_MAP_POINT_ITEM,
  'MA_MAP_ROAD': MA_MAP_ROAD,
  'MA_MAP_ROAD_LANE': MA_MAP_ROAD_LANE,
  'MAP_SUBITEM': MA_MAP_SUBITEM,
  'MA_SYSSET': MA_SYSSET,
  'ES_CARINFO': ES_CARINFO,
  'ES_EXAMPOINTDETAIL': ES_EXAMPOINTDETAIL,
  'MA_MARKRULESET': MA_MARKRULESET,
  'MA_CDSBINFO': MA_CDSBINFO,
  'MA_ITEMINFO': MA_ITEMINFO,
  'MA_T_CARPARMSET': MA_T_CARPARMSET,
  'ES_CAR_VIDEO_PARAMETER': ES_CAR_VIDEO_PARAMETER,
  'USER':USER,
  'IpConfigTable':IpConfigTable,
  'DeviceInfoTable':DeviceInfoTable,
  'CommonConstants':CommonConstants
}
const centerToMap={
  'ItemInfo':MA_ITEMINFO,
  'MarkRule':MA_MARKRULE,
  'SystemParm':MA_SYSTEMPARM,
  'mapCollectList':MA_MAP_COLLECT,
  'mapCollectshapeList':MA_MAP_COLLECT_SHAPE,
  'Map_Collect': MA_MAP_COLLECT,
  'Map_Collect_Shape': MA_MAP_COLLECT_SHAPE,
  'Map_ItemClass':MA_MAP_ITEMCLASS,
  'Map_Point':MA_MAP_POINT,
  'Map_Point_Item':MA_MAP_POINT_ITEM,
  'Map_Road':MA_MAP_ROAD,
  'Map_Road_Lane':MA_MAP_ROAD_LANE,
  'Map_SubItem':MA_MAP_SUBITEM,
  'Sysset':MA_SYSSET,
  'CarInfo':ES_CARINFO,
  // 'ES_EXAMPOINTDETAIL':ES_EXAMPOINTDETAIL,
  'MarkRuleSet':MA_MARKRULE,
  'Cdsbinfo':MA_CDSBINFO,
  'T_CarParmSet':MA_T_CARPARMSET,
  // 'ES_CAR_VIDEO_PARAMETER':ES_CAR_VIDE0pO_PARAMETER
}

function sqlInsertCommonFn(tableName,resultArr,context?){
  return new Promise((resolve,reject)=>{
    const accountTable = new AccountTable(() => {
    }, map[tableName],context);
    accountTable.getRdbStore(() => {
      accountTable.query('0',  async (result) => {
        // console.log('表长度',result.length,tableName)
        if (result.length == 0) {
          let INSERT_SQL = "INSERT INTO "+tableName
            + " ("+ map[tableName].ACCOUNT_TABLE.columns.toString()+") VALUES "

          resultArr.map((data,i) => {
            data.id=`${i}`
            let str='('
            map[tableName].ACCOUNT_TABLE.columns.map((res,index)=>{
              if(map[tableName].ACCOUNT_TABLE.columns.length-1==index){
                str+=data[res]?`"${data[res]}"`:'NULL'
              }else{
                str+=(data[res]?`"${data[res]}"`:'NULL')+','
              }
            })
            if(i==resultArr.length-1){
              str+=')'
            }else{
              str+='),'
            }
            INSERT_SQL+=str
          })
          accountTable.sqlOperate(INSERT_SQL,tableName,(val)=>{
            console.log('sqlsqlinsert,',val,'tableName',tableName)
            resolve(val)
          })
        }
        else {
          await delSyncTable(tableName,context)
          const result= await sqlInsertCommonFn(tableName,resultArr,context)
          resolve(result)
        }
      }, true);
    },context);
  })
}
//参数平台
export async function getDataBaseTable(params,reqParam) {
  return new Promise((resolve, reject) => {
    const accountTable = new AccountTable(() => {
    }, map[params.tableName],context);
    accountTable.getRdbStore(() => {
      accountTable.query('0', async (result) => {
        if (result.length != 0) {
          resolve();
          return
        } else {
          const date = new Date()
          if(!reqParam?.paraKdid){
            prompt.showToast({
              message: 'paraKdid获取失败',
              duration: 3000
            });
            return
          }
          const str = { "head": { "time": dateFormat(date) },
            "body":
            { "tableName": params.tableName, // 表名
              "paraKdid": reqParam.paraKdid, //参数平台kdid
              "examinationRoomId": reqParam.examinationRoomId, //考试平台kdid
              "typeRsp": "0" // 赋默认值0，无需改变
            }
          }
          let res: any = await initCenterCache(str)
          if( res.body[params.tableName].length==0){
            resolve();
            return
          }

          let INSERT_SQL = "INSERT INTO "+params.tableName
            + " ("+ map[params.tableName].ACCOUNT_TABLE.columns.toString()+") VALUES "
          if(params.tableName=='MA_SYSSET'){
            res.body[params.tableName]= res.body[params.tableName].filter(res=>{
              return res['v_no']>=300&&res['v_no']<=700
            })
          }

          res.body[params.tableName].map((data,i) => {
            // data.id=`${i}`
            data.id=i
            let str='('
            map[params.tableName].ACCOUNT_TABLE.columns.map((res,index)=>{
              if(map[params.tableName].ACCOUNT_TABLE.columns.length-1==index){
                str+=data[res]?`"${data[res]}"`:'NULL'
              }else{
                str+=(data[res]?`"${data[res]}"`:'NULL')+','
              }
            })
            if(i==res.body[params.tableName].length-1){
              str+=')'
            }else{
              str+='),'
            }
            INSERT_SQL+=str
          })

          accountTable.sqlOperate(INSERT_SQL,params.tableName,()=>{
            resolve(true)
          })
        }
      }, true);
    },reqParam.context);
  })
}
//依据数组和表名更新sql表
export async function upDateTableByArray(tableName,arr) {
  sqlInsertCommonFn(tableName,arr)
}
//更新双中心表
export async function upDateTable(params,reqParam) {
  return new Promise((resolve, reject) => {
    const date = new Date()
    let paraKdid=reqParam?.paraKdid||''
    let examinationRoomId=reqParam?.examinationRoomId||''
    if(!paraKdid|| !examinationRoomId){
      resolve(false)
      return
    }

    const str = { "head": { "time": dateFormat(date) },
      "body":
      { "tableName": params.tableName, // 表名
        "paraKdid": paraKdid, //参数平台kdid
        "examinationRoomId": examinationRoomId, //考试平台kdid
        "typeRsp": "0" // 赋默认值0，无需改变
      }
    }
    const url=globalThis.timeInfo.url

    initCenterCache(str,url).then(async (res)=>{
      if(!res||res==undefined||res==''){
        resolve(false)
        return
      }
      try {
        const result=await sqlInsertCommonFn(params.tableName,res.body[params.tableName],reqParam.context)
        resolve(result)
      }catch (error){
        console.log(error)
      }
    })
  });
}

//考试平台
export async function getMySystemSetTable(params,reqParam) {
  return new Promise((resolve, reject) => {
    const date = new Date()
    if(!reqParam.paraKdid){
      prompt.showToast({
        message: 'paraKdid获取失败',
        duration: 3000
      });
      return
    }
    const str = { "head": { "time": dateFormat(date) },
      "body":
      { "tableName": params.tableName, // 表名
        "paraKdid": reqParam?.kdid, //考试平台kdid
        "examinationRoomId": reqParam?.kdid, //考试平台kdid
        "typeRsp": "0" // 赋默认值0，无需改变
      }
    }
    initCenterCacheByKSPT(str).then((res)=>{
      if( res.body[params.tableName].length==0){
        resolve();
        return
      }
      if(params.tableName=='MA_SYSSET'){
        res.body[params.tableName]= res.body[params.tableName].filter(res=>{
          return res['v_no']<300 || res['v_no']>700
        })
      }
      sqlInsertCommonFn(params.tableName,res.body[params.tableName],reqParam.context).then((result)=>{
        resolve(result)
      })
    })


  })

}

//依据表名同步获取数据
export async function getSyncData(tableName,context?) {
  return new Promise((resolve, reject) => {
    const accountTable = new AccountTable(() => {
    }, map[tableName],context);
    accountTable.getRdbStore(() => {
      accountTable.query('0', async (result) => {
        resolve(result)
      }, true);
    });
  })

}

export async function delSyncTable(tableName,context?){
  return new Promise((resolve,reject)=>{
    const accountTable = new AccountTable(() => {
    }, map[tableName],context);
    accountTable.deleteTableData((ret)=>{
      console.log('删除成功')
      resolve(true)
    },tableName,context)

  })
}

//获取车模、场地模型
export async function getEsCarModel(context){
  const date = new Date()
  if(!globalThis.timeInfo?.paraKdid){
    prompt.showToast({
      message: 'paraKdid获取失败',
      duration: 3000
    });
    return
  }
  const carStr = { "head": { "time": dateFormat(date) },
    "body":
    {
      "rtkType":"1",//1:车模 2:场地模型
      "rspType":"0", //返回类型
      "paraKdid": globalThis.timeInfo.paraKdid, //参数平台kdid
      "examinationRoomId": globalThis.timeInfo.kdid, //考试平台kdid
      // "carMac":"MAC-HCPAD-210",
      "carMac":globalThis.deviceNo
    }
  }
  const venueStr =  { "head": { "time": dateFormat(date) },
    "body":
    {
      "rtkType":"2",//1:车模 2:场地模型
      "rspType":"0", //返回类型
      "paraKdid": globalThis.timeInfo.paraKdid, //参数平台kdid
      "examinationRoomId": globalThis.timeInfo.kdid, //考试平台kdid
      // "carMac":"MAC-HCPAD-210",
      "carMac":globalThis.deviceNo
    }
  }


  let carRes: any = await initEsModel(carStr);
  let venueRes: any = await initEsModel(venueStr);

  const carModel = carRes.body.ES_MODEL[0][1];
  const venueModel = venueRes.body.ES_MODEL[0][2];

  let tmpBase64Array = carModel.split("\r\n")
  let newBase64Str:string = '';
  for (let i = 0; i < tmpBase64Array.length; ++i) {
    newBase64Str += tmpBase64Array[i];
  }
  const base64 = new util.Base64();
  let result = base64.decodeSync(newBase64Str);
  const fileModel= new FileModel(context);
  await fileModel.initFolder()
  await fileModel.storingFiles(result.buffer)
}

export async function upDataZhongxinginitialization(param){
  return new Promise((resolve, reject) => {
    if(!param.carId){
      resolve(false)
      return
    }
    const str = {
      "carId":  param.carId, // 表名
      "examinationRoomId": param.examinationRoomId, //考试平台kdid
      videoVersion:'1.0',
      judgeVersion:param.judgeVersion,
      shellVersion:  param.shellVersion
    }
    console.log('daihai2')

    initialization(str).then((res)=>{
      console.log('daihai3',JSON.stringify(res))
      if(!res){
        resolve(false)
        return
      }
      let flag
      console.log('resposestart')

      for(let key in res.initializationRsp.body){
        if(!centerToMap[key]){
          continue
        }
        setSyncCenterSqlData(key,res,param).then((flag) => {
          if(!flag){
            resolve(false)
            return
          }{
            resolve(true)
          }
        }).catch ((error) => {
          resolve(false)
          console.log(error)
        })
      }
      console.log('daihai4')

      resolve(true)
      console.log('resposestart')

    }).catch((Error)=>{
      resolve(false)
    })
  })
}
function setSyncCenterSqlData(key,res,param){
  return new Promise((resolve,reject)=>{
    const mapName={
      'ItemInfo':'MA_ITEMINFO',
      'MarkRule':'MA_MARKRULE',
      'SystemParm':'MA_SYSTEMPARM',
      'Map_Collect': 'MA_MAP_COLLECT',
      'Map_Collect_Shape': 'MA_MAP_COLLECT_SHAPE',
      'Map_ItemClass':'MA_MAP_ITEMCLASS',
      'Map_Point':'MA_MAP_POINT',
      'Map_Point_Item':'MA_MAP_POINT_ITEM',
      'Map_Road':'MA_MAP_ROAD',
      'Map_Road_Lane':'MA_MAP_ROAD_LANE',
      'Map_SubItem':'MAP_SUBITEM',
      'Sysset':'MA_SYSSET',
      'CarInfo':'ES_CARINFO',
      // 'ES_EXAMPOINTDETAIL':ES_EXAMPOINTDETAIL,
      'MarkRuleSet':'MA_MARKRULESET',
      'Cdsbinfo':'MA_CDSBINFO',
      'T_CarParmSet':'MA_T_CARPARMSET',
      // 'ES_CAR_VIDEO_PARAMETER':ES_CAR_VIDE0pO_PARAMETER
    }
    // const accountTable = new AccountTable(() => {
    // }, centerToMap[key],param.context);
    let arrList
    if(res.initializationRsp.body[key].record instanceof  Array){
      arrList =res.initializationRsp.body[key].record
    }else{
      arrList=[res.initializationRsp.body[key].record]
    }
    console.log('mapName[key]',mapName[key],key)
    sqlInsertCommonFn(mapName[key],arrList,param.context).then((result)=>{
      console.log(key,'表建立成功')
      if(result){
        resolve(true)
      }else{
        resolve(false)
      }
    }).catch((msg)=>{
      reject(false)
      console.log(key,'表建立失败')
    })
  })

}