package service

import (
	"fmt"
	"time"

	"zeromesh/internal/model"
	"zeromesh/internal/repository"
)

type NodeService struct {
	nodeRepo *repository.NodeRepo
	userRepo *repository.UserRepo
}

func NewNodeService(nodeRepo *repository.NodeRepo, userRepo *repository.UserRepo) *NodeService {
	return &NodeService{nodeRepo: nodeRepo, userRepo: userRepo}
}

func (s *NodeService) Register(nodeID, publicKey, name, ipAddress string, port int, version string, userID uint) (*model.Node, error) {
	if userID > 0 {
		user, err := s.userRepo.FindByID(userID)
		if err != nil {
			return nil, fmt.Errorf("user not found")
		}
		if user.QuotaNodes >= 0 {
			used, _ := s.nodeRepo.CountByUser(userID)
			if used >= int64(user.QuotaNodes) {
				return nil, fmt.Errorf("node quota exceeded (%d)", user.QuotaNodes)
			}
		}
	}
	node := &model.Node{
		UserID:    userID,
		NodeID:    nodeID,
		PublicKey: publicKey,
		Name:      name,
		IPAddress: ipAddress,
		Port:      port,
		Online:    true,
		LastSeen:  now(),
		Version:   version,
	}
	if err := s.nodeRepo.Upsert(node); err != nil {
		return nil, err
	}
	return node, nil
}

func (s *NodeService) SetOnline(nodeID string, online bool) error {
	return s.nodeRepo.SetOnline(nodeID, online)
}

func (s *NodeService) ListNode(userID uint) ([]model.Node, error) {
	if userID == 0 {
		return s.nodeRepo.List()
	}
	return s.nodeRepo.ListByUser(userID)
}

func (s *NodeService) ListOnline(userID uint) ([]model.Node, error) {
	if userID == 0 {
		return s.nodeRepo.ListOnline()
	}
	nodes, err := s.nodeRepo.ListByUser(userID)
	if err != nil {
		return nil, err
	}
	var online []model.Node
	for _, n := range nodes {
		if n.Online {
			online = append(online, n)
		}
	}
	return online, nil
}

func (s *NodeService) GetNode(nodeID string) (*model.Node, error) {
	return s.nodeRepo.FindByNodeID(nodeID)
}

func (s *NodeService) CountByUser(userID uint) (int64, error) {
	return s.nodeRepo.CountByUser(userID)
}

func now() *time.Time {
	t := time.Now()
	return &t
}