// Package main is the main package of the Kerma node
package main

import (
	"kerma/helpers"
	"kerma/models"
	"kerma/utils"
	"net"
	"time"
)

var logger helpers.Logger

func main() {
	var config helpers.Config
	config.Construct()

	logger.Debug("!!!!! NODE RUNNING IN DEBUG MODE !!!!!")

	// Bind port
	logger.Info("Listening on " + config.ListenAddr)
	listener, err := net.Listen("tcp", config.ListenAddr)

	if err != nil {
		logger.Fatal("Failed binding port: " + err.Error())
	}

	// Define our in-memory state
	var state models.State
	state.Construct()

	// Close listener on exit
	defer listener.Close()

	// Accept connections and handle requests
	logger.Info("Performing handshake with known peers")
	for {
		go initNode(&state)
		startServer(&state, listener)
	}
}

func initNode(state *models.State) {
	for _, peer := range state.PeerList {
		if !state.CheckForHandshake(peer.Name) {
			timeout := state.Config.ConnTimeout * int(time.Second)
			d := net.Dialer{Timeout: time.Duration(timeout)}
			conn, err := d.Dial("tcp", peer.Name)

			if err != nil {
				logger.Error("Failed connecting to peer: " + err.Error())
				state.RemovePeerByName(peer.Name)
				continue
			}

			var handler utils.TCPHandler
			var client utils.Client
			handler.Construct(conn)
			client.Construct(state, handler)

			client.InitHandshake(peer.Name)
			client.DiscoverPeers(peer.Name)
			client.DiscoverChainTip(peer.Name)
			client.DiscoverMempool(peer.Name)

			var server utils.Server
			server.Construct(state, handler)
			go server.Handle()
			go client.GossipTransactions(peer.Name)
		}
	}
}

func startServer(state *models.State, l net.Listener) {
	conn, err := l.Accept()

	if err != nil {
		logger.Fatal("Failed listening on port: " + err.Error())
	}

	var handler utils.TCPHandler
	var server utils.Server

	handler.Construct(conn)
	server.Construct(state, handler)

	go server.Handle()
}