package repository

import (
	"time"

	"zeromesh/internal/database"
	"zeromesh/internal/model"
)

type NodeRepo struct {
	db *database.DB
}

func NewNodeRepo(db *database.DB) *NodeRepo {
	return &NodeRepo{db: db}
}

func (r *NodeRepo) Create(node *model.Node) error {
	return r.db.Create(node).Error
}

func (r *NodeRepo) FindByNodeID(nodeID string) (*model.Node, error) {
	var node model.Node
	err := r.db.Where("node_id = ?", nodeID).First(&node).Error
	if err != nil {
		return nil, err
	}
	return &node, nil
}

func (r *NodeRepo) Upsert(node *model.Node) error {
	var existing model.Node
	result := r.db.Where("node_id = ?", node.NodeID).First(&existing)
	if result.Error != nil {
		return r.db.Create(node).Error
	}
	existing.PublicKey = node.PublicKey
	existing.Name = node.Name
	existing.IPAddress = node.IPAddress
	existing.Port = node.Port
	existing.Version = node.Version
	return r.db.Save(&existing).Error
}

func (r *NodeRepo) SetOnline(nodeID string, online bool) error {
	now := time.Now()
	return r.db.Model(&model.Node{}).Where("node_id = ?", nodeID).Updates(map[string]interface{}{
		"online":    online,
		"last_seen": now,
	}).Error
}

func (r *NodeRepo) List() ([]model.Node, error) {
	var nodes []model.Node
	err := r.db.Order("id desc").Find(&nodes).Error
	return nodes, err
}

func (r *NodeRepo) ListByUser(userID uint) ([]model.Node, error) {
	var nodes []model.Node
	err := r.db.Where("user_id = ?", userID).Order("id desc").Find(&nodes).Error
	return nodes, err
}

func (r *NodeRepo) CountByUser(userID uint) (int64, error) {
	var count int64
	err := r.db.Model(&model.Node{}).Where("user_id = ?", userID).Count(&count).Error
	return count, err
}

func (r *NodeRepo) ListOnline() ([]model.Node, error) {
	var nodes []model.Node
	err := r.db.Where("online = ?", true).Find(&nodes).Error
	return nodes, err
}