package main

import (
	"bytes"
	"crypto/sha256"
	"path/filepath"
	"strconv"
	"sync"
	"time"

	"gitee.com/prestonTao/keystore"
	"gitee.com/prestonTao/libp2parea"
	"gitee.com/prestonTao/libp2parea/config"
	"gitee.com/prestonTao/libp2parea/engine"
	mc "gitee.com/prestonTao/libp2parea/message_center"
	"gitee.com/prestonTao/libp2parea/message_center/flood"
	"gitee.com/prestonTao/libp2parea/nodeStore"
	"gitee.com/prestonTao/utils"
)

func main() {
	engine.Log.Info("start")
	engine.SetLogPath("log.txt")

	StartAllPeer()
}

var (
	addrPre  = "SELF"
	areaName = sha256.Sum256([]byte("nihaoa a a proxy test!"))
	keyPwd   = "123456789"
	host     = "127.0.0.1"
	basePort = 19962
)

/*
启动所有节点
*/
func StartAllPeer() {
	nsm := nodeStore.NodeSimulationManager{IDdepth: 32 * 8}

	n := 1
	areaPeers := make([]*TestPeer, 0, n)
	for i := 0; i < n; i++ {
		area := StartOnePeer(i)
		areaPeers = append(areaPeers, area)
		nsm.AddNodeSuperIDs(area.area.GetNetId())
	}
	engine.Log.Info("--------------------------")
	engine.Log.Info("开始等待节点自治")
	//等待各个节点都准备好
	for _, one := range areaPeers {
		one.area.WaitAutonomyFinish()
		one.area.WaitAutonomyFinishVnode()
	}
	engine.Log.Info("--------------------------")
	engine.Log.Info("节点自治完成，打印逻辑节点")

	sleepTime := time.Second * 30
	engine.Log.Info("等待%s后打印关系", sleepTime)
	time.Sleep(sleepTime)

	// for i := 0; i < len(areaPeers); i++ {
	// 	logicNodes := areaPeers[i].area.NodeManager.GetAllNodes()
	// 	engine.Log.Info("machineIDInfo-------------------------------start")
	// 	for ii := range logicNodes {
	// 		engine.Log.Info("cur:%s curmachineID:%s target:%s tmachineID:%s", areaPeers[i].area.GetNetId().B58String(), areaPeers[i].area.GetMachineID(), logicNodes[ii].IdInfo.Id.B58String(), logicNodes[ii].MachineID)
	// 	}
	// 	engine.Log.Info("machineIDInfo-------------------------------end")
	// }

	select {}
}

type TestPeer struct {
	area *libp2parea.Area
}

func StartOnePeer(i int) *TestPeer {
	keyPath1 := filepath.Join("conf", "keystore"+strconv.Itoa(i)+".key")

	key1 := keystore.NewKeystore(keyPath1, addrPre)
	err := key1.Load()
	if err != nil {
		//没有就创建
		err = key1.CreateNewKeystore(keyPwd)
		if err != nil {
			panic("创建key1错误:" + err.Error())
		}
	}

	if key1.NetAddr == nil {
		_, _, err = key1.CreateNetAddr(keyPwd, keyPwd)
		if err != nil {
			panic("创建NetAddr错误:" + err.Error())
		}
	}
	if len(key1.GetAddr()) < 1 {
		_, err = key1.GetNewAddr(keyPwd, keyPwd)
		if err != nil {
			panic("创建Addr错误:" + err.Error())
		}
	}
	if len(key1.GetDHKeyPair().SubKey) < 1 {
		_, err = key1.GetNewDHKey(keyPwd, keyPwd)
		if err != nil {
			panic("创建Addr错误:" + err.Error())
		}
	}

	area, err := libp2parea.NewArea(areaName, key1, keyPwd)
	if err != nil {
		panic(err.Error())
	}
	area.SetLeveldbPath(config.Path_leveldb + strconv.Itoa(i))
	area.SetNetTypeToTest()

	area.SetMachineID("area_machine_id_3")

	// area.OpenVnode()

	area.SetDiscoverPeer(host + ":" + strconv.Itoa(19960))
	area.StartUP(false, host, uint16(basePort+i))

	peer := TestPeer{
		area: area,
	}

	peer.InitHandler(area)
	return &peer
}

const msg_id_p2p = 1001
const msg_id_p2p_recv = 1002 //加密消息

const msg_id_search = 1003
const msg_id_search_recv = 1004

const msg_id_multicast = 1009 //

func (this *TestPeer) InitHandler(area *libp2parea.Area) {
	area.Register_p2p(msg_id_p2p, this.RecvP2PMsgHandler)
	area.Register_p2p(msg_id_p2p_recv, this.RecvP2PMsgHandler_recv)

	area.Register_p2p(msg_id_search, this.SearchSuperHandler)
	area.Register_p2p(msg_id_search_recv, this.SearchSuperHandler_recv)

	area.Register_multicast(msg_id_multicast, this.MulticastMsgHandler)

	area.Register_nodeClosedCallback(this.NodeCloseCallbackFunc)
	area.Register_nodeBeenGodAddrCallback(this.NodeBeenGodAddrCallbackFunc)
}

var MsgCountLock = new(sync.Mutex)
var MsgCount = make(map[string]uint64)

func (this *TestPeer) RecvP2PMsgHandler(c engine.Controller, msg engine.Packet, message *mc.Message) {
	if !bytes.Equal(this.area.GetNetId(), *message.Head.RecvId) {
		engine.Log.Error("收到错误p2p消息self:%s recv:%s", this.area.GetNetId().B58String(), message.Head.RecvId.B58String())
		return
	}
	this.area.SendP2pReplyMsg(message, msg_id_p2p_recv, nil)
}

func (this *TestPeer) RecvP2PMsgHandler_recv(c engine.Controller, msg engine.Packet, message *mc.Message) {
	// engine.Log.Info("收到P2P消息返回 from:%s", message.Head.Sender.B58String())
	flood.ResponseBytes(utils.Bytes2string(message.Body.Hash), message.Body.Content)
}

func (this *TestPeer) SearchSuperHandler(c engine.Controller, msg engine.Packet, message *mc.Message) {
	engine.Log.Info("[%s] 收到p2p search消息 self:%s sender:%s sMID:%s recvId:%s", this.area.GetMachineID(), this.area.GetNetId().B58String(), message.Head.Sender.B58String(), message.Head.SenderMachineID, message.Head.RecvId.B58String())

	err := this.area.SendSearchSuperReplyMsg(message, msg_id_search_recv, nil)
	if err != nil {
		engine.Log.Error("SendSearchSuperReplyMsg error:%s", err.Error())
	}
}

func (this *TestPeer) SearchSuperHandler_recv(c engine.Controller, msg engine.Packet, message *mc.Message) {
	flood.ResponseBytes(utils.Bytes2string(message.Body.Hash), message.Body.Content)
}

func (this *TestPeer) MulticastMsgHandler(c engine.Controller, msg engine.Packet, message *mc.Message) {
	engine.Log.Info("收到广播消息:%s", this.area.GetNetId().B58String())
}

func (this *TestPeer) NodeCloseCallbackFunc(addr nodeStore.AddressNet, machineID string) {
	engine.Log.Info("qlw----- 节点关闭连接回调 cur:%s, node:%s, machineID:%s", this.area.GetNetId().B58String(), addr.B58String(), machineID)
}

func (this *TestPeer) NodeBeenGodAddrCallbackFunc(addr nodeStore.AddressNet, machineID string) {
	engine.Log.Info("qlw----- 节点被设置为上帝地址回调 cur:%s, node:%s, machineID:%s", this.area.GetNetId().B58String(), addr.B58String(), machineID)
}