package main

import (
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
	"proxy/internal/dto"
	"proxy/internal/model"
	"proxy/internal/util"
	"sync"
	"time"
)

var nodes = make([]*model.Node, 0)
var locker = sync.RWMutex{}

func register(c *gin.Context) {
	locker.Lock()
	defer locker.Unlock()

	ip := c.RemoteIP()

	var request dto.RegisterRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		dto.BadRequest(c, err)
		return
	}

	for _, node := range nodes {
		if node.Ip == ip {
			node.Ip = ip
			node.Secret = request.Secret
			node.CountryCode = request.CountryCode
			node.LastUpdateTime = time.Now()
			c.JSON(http.StatusOK, dto.RegisterResponse{
				Response: dto.NewOkResponse(),
				Data: dto.RegisterResult{
					Success: true,
				},
			})
			return
		}
	}
	node := &model.Node{
		Ip:             ip,
		Secret:         request.Secret,
		LastUpdateTime: time.Now(),
	}
	nodes = append(nodes, node)
	log.Printf("update nodes: %+v", nodes)
}

func list(c *gin.Context) {
	locker.RLock()
	defer locker.RUnlock()

	dtoNodes := make(map[string][]dto.Node)
	for _, node := range nodes {
		if _, ok := dtoNodes[node.CountryCode]; !ok {
			dtoNodes[node.CountryCode] = make([]dto.Node, 0)
		}
		if node.LastUpdateTime.Add(10 * time.Second).After(time.Now()) {
			dtoNodes[node.CountryCode] = append(dtoNodes[node.CountryCode], dto.Node{
				Ip: node.Ip,
			})
		}
	}

	listResult := make([]dto.ListResult, len(dtoNodes))
	i := 0
	for countryCode, itemNodes := range dtoNodes {
		listResult[i] = dto.ListResult{
			CountryCode: countryCode,
			Nodes:       itemNodes,
		}
		i++
	}

	c.JSON(http.StatusOK, dto.ListResponse{
		Response: dto.NewOkResponse(),
		Data:     listResult,
	})
}

func detail(c *gin.Context) {
	locker.RLock()
	defer locker.RUnlock()

	var request dto.DetailRequest
	if err := c.ShouldBindQuery(&request); err != nil {
		dto.BadRequest(c, err)
		return
	}

	for _, node := range nodes {
		if node.Ip == request.Ip {
			secret, err := util.RsaEncrypt([]byte(node.Secret))
			if err != nil {
				dto.Error(c, err)
				return
			}
			c.Data(http.StatusOK, "application/octet-stream", secret)
			return
		}
	}
	c.JSON(http.StatusNotFound, gin.H{
		"message": "not found ip",
	})
}

func health(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{"status": "up"})
}