package tool

import (
	"fmt"
	"log/slog"

	"trankilou.fr/lassistanoque/backend/internal/domain"
)

type Service struct {
	repo     domain.ToolRepository
	repoUser domain.UserRepository
	allTools map[string]domain.ITool
}

func NewService(
	repo domain.ToolRepository,
	repoUser domain.UserRepository,
) *Service {
	return &Service{
		repo:     repo,
		repoUser: repoUser,
		allTools: make(map[string]domain.ITool),
	}
}

func (s *Service) ListTools(userID string, teamID string) ([]*domain.Tool, error) {

	for _, tool := range s.allTools {
		_, err := s.repo.GetToolByName(userID, teamID, tool.Name())
		slog.Info("ListTools", "err1", err)
		if err != nil {
			_, err = s.repo.CreateTool(userID, &domain.Tool{
				TeamID:  teamID,
				Name:    tool.Name(),
				Enabled: true,
			})
			if err != nil {
				slog.Info("ListTools", "err2", err)
			}
		}
	}

	return s.repo.ListTools(userID, teamID)
}

func (s *Service) GetTool(userID string, teamID string, id string) (*domain.Tool, error) {
	return s.repo.GetToolByID(userID, teamID, id)
}

func (s *Service) GetToolByName(userID string, teamID string, name string) (*domain.Tool, error) {
	return s.repo.GetToolByName(userID, teamID, name)
}

func (s *Service) CreateTool(userID string, Tool *domain.Tool) (*domain.Tool, error) {

	if _, err := s.repoUser.FindUserTeam(userID, Tool.TeamID); err != nil {
		return nil, fmt.Errorf("error finding user in team: %s", err)
	}

	return s.repo.CreateTool(userID, Tool)
}

func (s *Service) UpdateTool(userID string, Tool *domain.Tool) (*domain.Tool, error) {
	if _, err := s.repoUser.FindUserTeam(userID, Tool.TeamID); err != nil {
		return nil, fmt.Errorf("error finding user in team: %s", err)
	}

	if _, err := s.repo.GetToolByID(userID, Tool.TeamID, Tool.ID); err != nil {
		return nil, fmt.Errorf("error finding Tool: %s", err)
	}

	return s.repo.UpdateTool(userID, Tool)
}

func (s *Service) DeleteTool(userID string, teamID string, id string) error {
	if _, err := s.repoUser.FindUserTeam(userID, teamID); err != nil {
		return fmt.Errorf("error finding user in team: %s", err)
	}

	if _, err := s.repo.GetToolByID(userID, teamID, id); err != nil {
		return fmt.Errorf("error finding Tool: %s", err)
	}

	return s.repo.DeleteTool(userID, teamID, id)

}

func (s *Service) RegisterToolImpl(tool domain.ITool) error {
	s.allTools[tool.Name()] = tool
	return nil
}

func (s *Service) GetAllToolImpl() map[string]domain.ITool {
	return s.allTools
}

func (s *Service) GetToolImpl(name string) domain.ITool {
	return s.allTools[name]
}