/*
 * 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(() => {
            globalThis.closeHeartSocket=false
            console.log(`${TAG} udp bind success`);
        }).catch(err => {
            globalThis.closeHeartSocket=true
            console.log(`${TAG} udp bind failed:${JSON.stringify(err)}`);
        });
    }
    initHeartSendMsg(param,context){
        console.log('1111param',JSON.stringify(param))
        this.initParam=param
        this.context=context
    }
    bindUdp() {
        let promise = this.udp.bind({
            address: this.localIp, port: parseInt(this.localIpPort), family: 1
        });
        promise.then(() => {
            globalThis.closeHeartSocket=false
            console.log(`${TAG} udp bind success`);
        }).catch(err => {
            globalThis.closeHeartSocket=true
            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}){
        console.log('globalThis.lshNo',globalThis.lshNo)
        let a = string2Bytes(`${id}${fillZero(placeId,3)}`, 2*8);
        console.log('aaa',a)
        let b = string2Bytes(`${fillZero(carNo,4)}${globalThis.lshNo}`, 4*8);
        console.log('bbb',b)
        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)}`);
        });
    }
    onError(callback?){
        this.udp.on('error',async err => {
            globalThis.closeHeartSocket=true
            callback&&callback()
            // callback&&callback()
            // this.closeUdp(()=>{
            //   this.bindUdp()
            // })
        });
    }
    setMsgCallBack(callback){
        this.stashFn=callback?callback:()=>{}
    }
    sendMsg(param,context?) {
        this.udp.getState((err, data) => {
            if (err) {
                globalThis.closeHeartSocket=true
                return;
            }else{
                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})
        });
    }

    closeUdp(callback) {
        globalThis.closeHeartSocket=true
        this.udp.close(err=>{
            if(err){

            }else{
                this.udp.getState((err, data) => {
                    if (err) {
                        return;
                    }else{
                        globalThis.closeHeartSocket=true
                        if(!data.isisClose){
                            setTimeout(()=>{
                                callback()
                            },1000)
                        }
                    }
                })
                // let promise = this.udp.getState({});
                // promise.then(data => {
                //
                //     console.log('getState success:' + JSON.stringify(data));
                // }).catch(err => {
                //     callback()
                //     console.log('getState fail');
                // });
            }
        });

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