package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"sync"
	"time"
)

var (
	connCode      string
	peers         []string
	connCodeMutex sync.Mutex
)

type Message struct {
	ID      string `json:"id"`
	Type    string `json:"type"`
	Content string `json:"content"`
}

func loadNodeConfig() {
	config := loadConfig()
	connCode = config.ConnectionCode
	peers = config.Peers
}

func handleNodeRequest(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
		return
	}

	connCodeMutex.Lock()
	defer connCodeMutex.Unlock()

	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "Error reading request body", http.StatusInternalServerError)
		return
	}
	defer r.Body.Close()

	var msg Message
	if err := json.Unmarshal(body, &msg); err != nil {
		http.Error(w, "Error parsing JSON", http.StatusBadRequest)
		return
	}

	if msg.ID != connCode {
		http.Error(w, "Authentication failed", http.StatusUnauthorized)
		return
	}

	interpretMessage(msg)
	fmt.Fprintln(w, "Message received")
}

func interpretMessage(msg Message) {
	switch msg.Type {
	case "test":
		fmt.Println("Received test message:", msg.Content)
	case "get-version":
		fmt.Println("Received get-version message")
		// Handle get-version logic here
	case "update":
		fmt.Println("Received update message:", msg.Content)
		// Handle update logic here
		go update()
	default:
		fmt.Println("Received unknown message type:", msg.Type)
	}
}

func sendMessage(address, id, msgType, content string) error {
	msg := Message{
		ID:      id,
		Type:    msgType,
		Content: content,
	}
	msgBytes, err := json.Marshal(msg)
	if err != nil {
		return err
	}

	req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/node", address), bytes.NewBuffer(msgBytes))
	if err != nil {
		return err
	}
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := ioutil.ReadAll(resp.Body)
		return fmt.Errorf("failed to send message: %s", body)
	}

	return nil
}

func startNodeClient(addresses []string) {
	for _, address := range addresses {
		go func(addr string) {
			for {
				err := sendMessage(addr, connCode, "test", "This is a test message")
				if err != nil {
					fmt.Println("Error sending test message to", addr, ":", err)
					continue
				}
				time.Sleep(10 * time.Second)
			}
		}(address)
	}
}