import socket from '@ohos.net.socket';
import hilog from '@ohos.hilog';
import { getTCP } from './GlobalTcp';
import prompt from '@ohos.prompt';

const TAG = 'socketTag[TcpDemo.TcpClient]'

export default class TcpClient {
  private localIp: string = ''
  private localIpPort: string = ''
  private oppositeIp: string = ''
  private oppositeIpPort: string = ''
  private num: number = 0//重连次数

  private tcp: any = null

  constructor(tcplocalIp: string, tcplocalIpPort: string, tcpOppositeIp: string, tcpOppositePort: string) {
    this.localIp = tcplocalIp
    this.oppositeIp = tcpOppositeIp
    this.localIpPort = tcplocalIpPort
    this.oppositeIpPort = tcpOppositePort
    console.log(TAG, 'new Tcp', this.localIp, this.localIpPort, this.oppositeIp, this.oppositeIpPort)
    this.tcp = socket.constructTCPSocketInstance();
  }

  onError(callback?) {
    this.tcp.on('error', err => {
      console.log(TAG, 'tcpOnerror', JSON.stringify(err))
      setTimeout(async () => {
        getTCP()
      }, 2000)
      // this.closeUdp(()=>{
      //   this.bindUdp()
      // })
    });
  }

  rebindTcp(localIp: string, localIpPort: string, oppositeIp: string, oppositeIpPort: string) {
    return new Promise((resolve, reject) => {
      this.localIp = localIp
      this.oppositeIp = oppositeIp
      this.localIpPort = localIpPort
      this.oppositeIpPort = oppositeIpPort
      console.log(TAG, 'tcpreBind', this.localIp, this.localIpPort)
      let promise = this.tcp.bind({
        address: this.localIp, port: parseInt(this.localIpPort), family: 1
      }, err => {
        if (err) {
          globalThis.getCloseTcp = true
          hilog.info(0x0000, 'testTag', "tcpreBinderror:" + JSON.stringify(err));
          resolve(true)
        }
        console.log('testTag,rebindtestTag tcp bind success');
        globalThis.getCloseTcp = false
        resolve(false)

      })
    })

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

  }

  bindTcp() {
    console.log(TAG, 'tcpbind', this.localIp, 'localIp', this.localIpPort)
    return new Promise((resolve, reject) => {
      let promise = this.tcp.bind({
        address: this.localIp, port: parseInt(this.localIpPort), family: 1
      }, err => {
        if (err) {
          console.log('testTag tcp bind faile');
          globalThis.getCloseTcp = true
          hilog.info(0x0000, 'testTag', "tcpBinderror:" + JSON.stringify(err));
          resolve(true)
          return
        }
        globalThis.getCloseTcp = false
        console.log('testTag tcp bind success');
        resolve(false)
      })
    })
    console.log('localIp', this.localIp)
    console.log('localIpPort', this.localIpPort)
    // let promise = this.udp.bind({
    //     // address: '192.168.7.170', port: 20122, family: 1
    //     // address: '192.168.7.170', port: 31013, family: 1
    //     address: this.localIp, port: parseInt(this.localIpPort), family: 1
    // });


  }

  connectTcp() {
    console.log(TAG, 'tcpConnect', this.oppositeIp, 'localIp', this.oppositeIpPort)
    return new Promise((resolve, reject) => {
      let promise = this.tcp.connect({
        address: {
          address: this.oppositeIp, port: parseInt(this.oppositeIpPort), family: 1
        }, timeout: 6000
      });
      promise.then(() => {

        this.tcp.setExtraOptions({
          keepAlive: true,
          // OOBInline: true,
          // TCPNoDelay: true,
          // socketLinger: { on:true, linger:10 },
          // receiveBufferSize: 1000,
          // sendBufferSize: 1000,
          // reuseAddress: true,
          // socketTimeout: 3000,
        }, err => {
          if (err) {
            console.log('testTagtestTagerrrrr,success')
            if(this.num>3){
              return
            }
            setTimeout(() => {
              getTCP()
              resolve(false)
            }, 2000)
            return;
          }
        });
        console.log('testTagtestTagconnect,success')

        globalThis.getCloseTcp = false
        resolve(true)
      }).catch(err => {
        globalThis.getCloseTcp = true
        this.num++
        if(this.num>3){
          return
        }
        setTimeout(() => {
          getTCP()
          resolve(false)
        }, 2000)
        console.log('testTagtestTagconnect,error')

      });
    })
  }

  sendMsg(msg: string) {
    console.log(TAG, 'tcpSend', msg.length, msg)
    return new Promise((reslove, reject) => {
      let promise = this.tcp.send({
        data: msg
      });
      promise.then(() => {
        reslove(true)
      }).catch(err => {
        reslove(false)
      });
    })
  }

  onMessage(callback?) {
    this.tcp.on('message', value => {
      console.log(TAG, 'Tcponmessage', value)
      globalThis.tcpUdpError = false

      // console.log('messageLengt',,value.message.length))
      console.log('testTagtcpmsg')
      // console.log("on message, message:" + value.message+ ", remoteInfo:" )
      if (value) {
        let dataView = new DataView(value.message)
        // const Arraybuffer=buffer.from(value.message, 5, dataView?.byteLength);
        const Arraybuffer = value.message.slice(5, dataView?.byteLength);

        callback && callback(Arraybuffer)
      } else {
        callback && callback('')
      }
      clearInterval(globalThis.intervaltcp)
      globalThis.intervaltcp=setInterval(()=>{
        setTimeout(async () => {
          //程序断开
          if (globalThis.tcpUdpError) {
            console.log(TAG,'tcp信号丢失')
            getTCP()
            prompt.showToast({
              message: 'tcp信号丢失',
              duration: 2000
            });
          }
          globalThis.tcpUdpError = true;
        }, 2000)
      },3000)

      // callback(value.message)
    });
  }

  offTcp(callback) {
    console.log(TAG, 'tcpofff')

    this.tcp.off('testTagofmessg', callback);
  }

  closeTcp(callback) {
    return new Promise((reslove, reject) => {
      console.log(TAG, 'tcpClose')
      let promise = this.tcp.close();
      promise.then(() => {
        globalThis.getCloseTcp = true

        console.log(TAG, 'tcpCloseSuccess')
        callback()
        reslove(true)
      }).catch(err => {
        console.log(TAG, 'tcpClosefailed')
        reslove(false)
      });
    })
  }
}