package service

import (
	"database/sql"
	"errors"

	"aggios-app/backend/internal/domain"
	"aggios-app/backend/internal/repository"

	"github.com/google/uuid"
)

var (
	ErrTenantNotFound = errors.New("tenant not found")
)

// TenantService handles tenant business logic
type TenantService struct {
	tenantRepo *repository.TenantRepository
}

// NewTenantService creates a new tenant service
func NewTenantService(tenantRepo *repository.TenantRepository) *TenantService {
	return &TenantService{
		tenantRepo: tenantRepo,
	}
}

// Create creates a new tenant
func (s *TenantService) Create(req domain.CreateTenantRequest) (*domain.Tenant, error) {
	// Check if subdomain already exists
	exists, err := s.tenantRepo.SubdomainExists(req.Subdomain)
	if err != nil {
		return nil, err
	}
	if exists {
		return nil, ErrSubdomainTaken
	}

	tenant := &domain.Tenant{
		Name:      req.Name,
		Domain:    req.Domain,
		Subdomain: req.Subdomain,
	}

	if err := s.tenantRepo.Create(tenant); err != nil {
		return nil, err
	}

	return tenant, nil
}

// GetByID retrieves a tenant by ID
func (s *TenantService) GetByID(id uuid.UUID) (*domain.Tenant, error) {
	tenant, err := s.tenantRepo.FindByID(id)
	if err != nil {
		return nil, err
	}
	if tenant == nil {
		return nil, ErrTenantNotFound
	}
	return tenant, nil
}

// GetBySubdomain retrieves a tenant by subdomain
func (s *TenantService) GetBySubdomain(subdomain string) (*domain.Tenant, error) {
	tenant, err := s.tenantRepo.FindBySubdomain(subdomain)
	if err != nil {
		return nil, err
	}
	if tenant == nil {
		return nil, ErrTenantNotFound
	}
	return tenant, nil
}

// ListAll retrieves all tenants
func (s *TenantService) ListAll() ([]*domain.Tenant, error) {
	return s.tenantRepo.FindAll()
}

// Delete removes a tenant by ID
func (s *TenantService) Delete(id uuid.UUID) error {
	if err := s.tenantRepo.Delete(id); err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return ErrTenantNotFound
		}
		return err
	}
	return nil
}