package provider

import (
	"context"
	"fmt"
	"strings"

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

type Service struct {
	repo      domain.ProviderRepository
	repoUser  domain.UserRepository
	llmengine domain.LLMEngine
}

func NewService(
	repo domain.ProviderRepository,
	repoUser domain.UserRepository,
	llmengine domain.LLMEngine,
) *Service {
	return &Service{
		repo,
		repoUser,
		llmengine,
	}
}

func (s *Service) ListProviderTypes() []domain.Item {
	return s.llmengine.ListProviderTypes()
}

func (s *Service) ListProviders(userID string, teamID string) ([]*domain.Provider, error) {
	return s.repo.ListProviders(userID, teamID)
}

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

	items := make([]*domain.ComplexItem, 0)

	providers, err := s.repo.ListProviders(userID, teamID)
	if err != nil {
		return nil, err
	}
	for _, provider := range providers {
		models := strings.Split(provider.Models, "|")
		for _, m := range models {
			items = append(items, &domain.ComplexItem{
				Group: provider.Name,
				Value: provider.ID + "|" + m,
				Label: m,
			})
		}
	}

	return items, nil
}

func (s *Service) GetProvider(userID string, teamID string, id string) (*domain.Provider, error) {
	return s.repo.GetProvider(userID, teamID, id)
}

func (s *Service) CreateProvider(userID string, provider *domain.Provider) (*domain.Provider, error) {

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

	return s.repo.CreateProvider(userID, provider)
}

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

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

	return s.repo.UpdateProvider(userID, provider)
}

func (s *Service) DeleteProvider(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.GetProvider(userID, teamID, id); err != nil {
		return fmt.Errorf("error finding provider: %s", err)
	}

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

}

func (s *Service) ListAvailableModels(ctx context.Context, provider *domain.Provider) ([]string, error) {
	return s.llmengine.ListModelsFromProvider(ctx, provider)
}