/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import socket from '@ohos.net.socket';
import fs from '@ohos.file.fs'
import mediaLibrary from '@ohos.multimedia.mediaLibrary'
import FileUtil from '../../common/utils/File'
import { fillZero, string2Bytes } from '../utils/tools'
import { GlobalConfig } from '../../config/index'

const TAG = '[UdpDemo.UdpClient]'
// import common from '@ohos.app.ability.common';
import hilog from '@ohos.hilog';
import prompt from '@ohos.prompt'
import call from '@ohos.telephony.call';


export default class UdpClientByCenter {
  private localIp: string = ''
  private localIpPort: string = ''
  private oppositeIp: string = ''
  private oppositeIpPort: string = ''
  private udpMsg: any = ''
  private num: number = 0
  private fileUtil: FileUtil
  private udp: any = null
  private sendId: any = 0
  private lsh: string = null
  private context
  private stashFn: StashFunction
  private headLenth: number = 9
  //消息头长度
  private initParam

  constructor(udplocalIp: string, udplocalIpPort: string, udpOppositeIp: string, udpOppositeIpPort: string) {
    this.localIp = udplocalIp
    this.oppositeIp = udpOppositeIp
    this.localIpPort = udplocalIpPort
    this.oppositeIpPort = udpOppositeIpPort
    this.stashFn = () => {
    }
    this.udp = socket.constructUDPSocketInstance();
  }

  rebindUdp(localIp: string, localIpPort: string, oppositeIp: string, oppositeIpPort: string) {
    this.localIp = localIp
    this.oppositeIp = oppositeIp
    this.localIpPort = localIpPort
    this.oppositeIpPort = oppositeIpPort

    let promise = this.udp.bind({
      // address: '192.168.7.170', port: 20122, family: 1
      address: this.localIp, port: parseInt(this.localIpPort), family: 1
    });

    promise.then(() => {
      console.log(`${TAG} udp bind success`);
    }).catch(err => {

      console.log(`${TAG} udp bind failed:${JSON.stringify(err)}`);
    });
  }

  initHeartSendMsg(param, context) {
    this.initParam = param
    this.context = context
  }

  bindUdp() {
    let promise = this.udp.bind({
      address: this.localIp, port: parseInt(this.localIpPort), family: 1
    });
    promise.then(() => {
      console.log(`${TAG} udp bind success`);
    }).catch(err => {

      console.log(`${TAG} udp bind failed:${JSON.stringify(err)}`);
    });
  }

  //异或运算
  setMessageExclusive(tmpList) {
    let result = tmpList[0];
    for (let i = 1; i < tmpList.length; i++) {
      result = result ^ tmpList[i]
    }
    return [result];
  }

  Array2Byte(array) {
    var buf = new ArrayBuffer(array.length);
    var view = new Uint8Array(buf);
    for (var i = 0; i != array.length; ++i) {
      view[i] = array[i] & 0xFF;
    }
    return view;
  }

  //length消息体bufferlength   id消息类型id  bodyStr消息体string
  // setMsyBody(id,bodyByte){

  // {id: 31,list:[0,1,'0000000000000'],carNo:489,placeId:62}
  setWholeMsg(params) {
    let head = this.setMsgHead(params);
    let headJudge = this.setMessageExclusive(head);
    let body = this.setMsgBody(params);
    let bodyJudge = this.setMessageExclusive(body);
    let end = [13, 10];
    const arr = [...head, ...headJudge, ...body, ...bodyJudge, ...end]
    console.log('BitArray', arr)
    return this.Array2Byte(arr).buffer

  }

  setMsgHead({id, list, placeId=62, carNo=489}) {
    let a = string2Bytes(`${id}${fillZero(placeId, 3)}`, 2 * 8);
    let b = string2Bytes(`${carNo}${this.lsh}`, 4 * 8);

    let c = string2Bytes(list.length, 2 * 8);
    return [...a, ...b, ...c];
  }

  setMsgBody({id,list}) {
    let tmpList = []
    tmpList = list

    return tmpList;

  }

  sendHeadMsg(msgData) {
    console.log('sendsnd1')
    //udpOppositeIp
    let promise = this.udp.send({
      data: msgData,
      address: {
        address: this.oppositeIp,
        port: parseInt(this.oppositeIpPort),
      }
    });
    promise.then(() => {
      console.log(`${TAG} udpLine send success:`);
    }).catch(err => {
      console.log(`${TAG} udpLine send fail:${JSON.stringify(err)}`);
    });
  }

  setMsgCallBack(callback) {
    this.stashFn = callback ? callback : () => {
    }
  }

  sendMsg(param, context?) {
    console.log('paramparam', JSON.stringify(param))
    if (context) {
      this.context = context
    }
    this.sendId = param.id
    console.log('sendMsg', JSON.stringify(param))
    const msgData = this.setWholeMsg(param)
    // const msgData=this.setMsyBody('31','010000000000000')
    let promise = this.udp.send({
      data: msgData,
      address: {
        address: this.oppositeIp,
        port: parseInt(this.oppositeIpPort),
      }
    });
    promise.then(() => {
      if (param.sendCallback) {
        param.sendCallback()
      }
      // if(this.sendId=='46'&&param.callback){
      //     param.callback()
      // }
      console.log(`${TAG} udp send success:`);
    }).catch(err => {
      console.log(`${TAG} udp send fail:${JSON.stringify(err)}`);
    });
  }

  onMessage(callback, type?) {
    this.udp.on('message', value => {
      let arr = []
      let dataView = new DataView(value.message)
      for (let i = 0; i < dataView?.byteLength; ++i) {
        arr[i] = dataView?.getUint8(i)
      }
      let idNum = '0x' + fillZero(arr[1].toString(16), 2) + fillZero(arr[0].toString(16), 2);
      let id = Math.floor(+idNum / 1000)
      hilog.info(0x0000, 'bitbit', JSON.stringify(arr));

      let lengthNum = '0x' + fillZero(arr[7].toString(16), 2) + fillZero(arr[6].toString(16), 2);
      let length = +lengthNum;
      let list = []
      for (let i = this.headLenth; i <= this.headLenth + length - 1; i++) {
        list.push(arr[i])
      }
      this.stashFn({
        id, length, body: list, sendId: this.sendId
      })
      callback({
        id, length, body: list, sendId: this.sendId
      })
    });
  }

  onError(callback?) {
    this.udp.on('error', err => {
      console.log('udpbycenterdiushierroring')
      hilog.info(0x0000, 'udpCLientBycenteronerror', 'error' + JSON.stringify(err));
      console.log("on error, err:" + JSON.stringify(err))
      // this.closeUdp(()=>{
      //   this.bindUdp()
      // })
    });
  }

  closeUdp() {
    return new Promise<void>((resolve, reject) => {
      this.udp.close().then(() => {
        hilog.info(0x0000, 'udpClient', 'close');
        return this.udp.getState()
      }).then((data) => {
        if (!data.isClose) {
          setTimeout(() => {
            resolve()
          }, 1000)
        }
      }).catch(err => {
        hilog.error(0x0000, 'udpClient', err);
        reject(err)
      })
    })
  }
}

interface StashFunction {
  (params: {
    id: number;
    length: number;
    body: any[];
    sendId: string
  }): void;
}