import os
import sys
import json
import socket
import threading
import time


import prot_codec as pc
from log import myprint
from log import log_init



# tcp 客户端脚本
# 一个本地服务端
# 一个远程客户端



_LOCAL_PORT = 31234

_remote_client=None
_local_client=[]
_local_server=None




_local_client_lock = threading.Lock()




# 发送数据到指定ip地址和端口
def send_to(ip,port,data:bytearray):
  for item in _local_client:
    if(item[1]==ip and item[2]==port):
      item[0].send(data)
      return
  myprint(f"can not fond {ip}:{port}")


# 关闭指定地址的端口
def close(ip,port):
  global _local_client
  global _local_client_lock
  _local_client_lock.acquire()
  for item in _local_client:
    if(item[1]==ip and item[2]==port):
      myprint(f'断开连接 {ip}:{port}')
      item[0].close()
      _local_client.remove(item)
      break
  _local_client_lock.release()

# 关闭所有
def close_all():
  global _local_client
  global _local_client_lock
  _local_client_lock.acquire()
  for item in _local_client:
    item[0].close()
  _local_client=[]
  _local_client_lock.release()
  myprint('连接列表已清空')




# 远端数据处理，解包，把负载数据发送到本地服务器
# 这个线程只会创建一个，用于连接代理服务器
def remote_client_handler(tcp_remote:socket):
  global _remote_client
  global _local_client
  global _local_server
  myprint("已连接代理服务器")
  recv_data=bytearray()
  cmd={'device':'client','option':'login'}
  data=pc.encode(json.dumps(cmd).encode('utf-8'),b'default')
  _remote_client.send(data)
  while True:
    try:
      recv = tcp_remote.recv(4096)
    except Exception as e:
      myprint("代理服务器连接异常",str(e))
      break
    if recv:
      recv_data+=recv
      while True:
        start=recv_data.find(b'\xff')
        end=recv_data.find(b'\xfe')
        if(start==-1 or end==-1):
          break
        cmd,data=pc.decode(recv_data[start:end+1])
        myprint(cmd.decode('utf-8'))
        try:
          j=json.loads(cmd)
          if(j['device']=='server'):
            if(j['option']=='data'):
              myprint(f"收到数据 {j['ip']}:{j['port']}")
              send_to(j['ip'],j['port'],data)
            elif(j['option']=='disconnect'):
              myprint(f"收到服务器的断开通知 {j['ip']}:{j['port']}")
              close(j['ip'],j['port'])
          elif(j['device']=='proxy'):
            if(j['option']=='close'):
              myprint("收到代理服务器的断开通知")
              close_all()
        except Exception as e:
          myprint(str(e))
        recv_data=recv_data[end+1:]
    else:
      break
  tcp_remote.close()
  myprint("代理服务器已断开")
  close_all()
  if _local_server is not None:
    _local_server.close()


# 本地数据处理，解包，把负载数据发送到本地服务器
# 每个本地连接都会创建一个线程
def local_client_handler(tcp_server:socket,addr):
  global _remote_client
  global _local_client
  myprint("addr:",addr)
  addr_info=(tcp_server,addr[0],addr[1])
  _local_client.append(addr_info)
  if(_remote_client is not None):
    cmd={'device':'client','option':'connect','ip':addr[0],'port':addr[1]}
    data=pc.encode(json.dumps(cmd).encode('utf-8'),b'default')
    _remote_client.send(data)
  while True:
    try:
      recv = tcp_server.recv(4096)
    except Exception as e:
      myprint("local:",str(e))
      break
    if recv:
      cmd={'device':'client','option':'data','ip':addr[0],'port':addr[1]}
      data=pc.encode(json.dumps(cmd).encode('utf-8'),recv)
      if _remote_client is not None:
        _remote_client.send(data)
        myprint(f"发送数据 {addr[0]}:{addr[1]}")
    else:
      break
  close(addr[0],addr[1])
  cmd={'device':'client','option':'disconnect','ip':addr[0],'port':addr[1]}
  data=pc.encode(json.dumps(cmd).encode('utf-8'),b'default')
  if(_remote_client is not None):
    try:
      myprint(f"发送断开通知到服务器端 {addr[0]}:{addr[1]}")
      _remote_client.send(data)
    except Exception as e:
      myprint("远端连接异常",str(e))



def main():
  global _remote_client
  global _local_client
  global _local_server

  _remote_client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  _remote_client.connect(("1.92.113.30",5345))
  thd = threading.Thread(target = remote_client_handler, args = (_remote_client,))
  thd.start()
  _local_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
  _local_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
  _local_server.bind(("",_LOCAL_PORT))
  myprint(f"开始监听({_LOCAL_PORT})")
  _local_server.listen(128)
  while True:
      try:
        temp , temp_address = _local_server.accept()
      except Exception as e:
        myprint("local server:",str(e))
        break
      thd = threading.Thread(target = local_client_handler, args = (temp,temp_address))
      thd.start()


if __name__ == "__main__":
  log_init("target_client.log")
  main()