package service

import (
	"context"
	"time"

	"bugulma/backend/internal/domain"

	"github.com/google/uuid"
)

type ContentService struct {
	pageRepo         domain.StaticPageRepository
	announcementRepo domain.AnnouncementRepository
	mediaRepo        domain.MediaAssetRepository
}

func NewContentService(
	pageRepo domain.StaticPageRepository,
	announcementRepo domain.AnnouncementRepository,
	mediaRepo domain.MediaAssetRepository,
) *ContentService {
	return &ContentService{
		pageRepo:         pageRepo,
		announcementRepo: announcementRepo,
		mediaRepo:        mediaRepo,
	}
}

// Static Pages

// ListPages lists static pages with optional filters
func (s *ContentService) ListPages(ctx context.Context, filters map[string]interface{}) ([]*domain.StaticPage, error) {
	return s.pageRepo.GetAll(ctx)
}

// GetPage retrieves a page by slug
func (s *ContentService) GetPage(ctx context.Context, slug string) (*domain.StaticPage, error) {
	return s.pageRepo.GetBySlug(ctx, slug)
}

// CreatePage creates a new static page
func (s *ContentService) CreatePage(ctx context.Context, page *domain.StaticPage) error {
	page.ID = uuid.New().String()
	if page.Status == "" {
		page.Status = domain.PageStatusDraft
	}
	if page.Visibility == "" {
		page.Visibility = domain.PageVisibilityPublic
	}
	return s.pageRepo.Create(ctx, page)
}

// UpdatePage updates a static page
func (s *ContentService) UpdatePage(ctx context.Context, page *domain.StaticPage) error {
	return s.pageRepo.Update(ctx, page)
}

// DeletePage deletes a static page
func (s *ContentService) DeletePage(ctx context.Context, id string) error {
	return s.pageRepo.Delete(ctx, id)
}

// PublishPage publishes a page
func (s *ContentService) PublishPage(ctx context.Context, id string) error {
	page, err := s.pageRepo.GetByID(ctx, id)
	if err != nil {
		return err
	}
	now := time.Now()
	page.Status = domain.PageStatusPublished
	page.PublishedAt = &now
	return s.pageRepo.Update(ctx, page)
}

// Announcements

// ListAnnouncements lists announcements with filters
func (s *ContentService) ListAnnouncements(ctx context.Context, filters domain.AnnouncementFilters) ([]*domain.Announcement, error) {
	return s.announcementRepo.GetAll(ctx, filters)
}

// GetAnnouncement retrieves an announcement by ID
func (s *ContentService) GetAnnouncement(ctx context.Context, id string) (*domain.Announcement, error) {
	return s.announcementRepo.GetByID(ctx, id)
}

// CreateAnnouncement creates a new announcement
func (s *ContentService) CreateAnnouncement(ctx context.Context, announcement *domain.Announcement) error {
	announcement.ID = uuid.New().String()
	if announcement.Priority == "" {
		announcement.Priority = domain.AnnouncementPriorityNormal
	}
	if announcement.DisplayType == "" {
		announcement.DisplayType = domain.AnnouncementDisplayBanner
	}
	if announcement.TargetAudience == "" {
		announcement.TargetAudience = domain.AnnouncementTargetAll
	}
	return s.announcementRepo.Create(ctx, announcement)
}

// UpdateAnnouncement updates an announcement
func (s *ContentService) UpdateAnnouncement(ctx context.Context, announcement *domain.Announcement) error {
	return s.announcementRepo.Update(ctx, announcement)
}

// DeleteAnnouncement deletes an announcement
func (s *ContentService) DeleteAnnouncement(ctx context.Context, id string) error {
	return s.announcementRepo.Delete(ctx, id)
}

// GetActiveAnnouncements retrieves active announcements
func (s *ContentService) GetActiveAnnouncements(ctx context.Context) ([]*domain.Announcement, error) {
	return s.announcementRepo.GetActive(ctx)
}

// Media Assets

// ListMediaAssets lists media assets with filters
func (s *ContentService) ListMediaAssets(ctx context.Context, filters domain.MediaAssetFilters) ([]*domain.MediaAsset, error) {
	return s.mediaRepo.GetAll(ctx, filters)
}

// GetMediaAsset retrieves a media asset by ID
func (s *ContentService) GetMediaAsset(ctx context.Context, id string) (*domain.MediaAsset, error) {
	return s.mediaRepo.GetByID(ctx, id)
}

// CreateMediaAsset creates a new media asset
func (s *ContentService) CreateMediaAsset(ctx context.Context, asset *domain.MediaAsset) error {
	asset.ID = uuid.New().String()
	return s.mediaRepo.Create(ctx, asset)
}

// UpdateMediaAsset updates a media asset
func (s *ContentService) UpdateMediaAsset(ctx context.Context, asset *domain.MediaAsset) error {
	return s.mediaRepo.Update(ctx, asset)
}

// DeleteMediaAsset deletes a media asset
func (s *ContentService) DeleteMediaAsset(ctx context.Context, id string) error {
	return s.mediaRepo.Delete(ctx, id)
}

// SearchMediaAssets searches media assets
func (s *ContentService) SearchMediaAssets(ctx context.Context, query string) ([]*domain.MediaAsset, error) {
	return s.mediaRepo.Search(ctx, query)
}