package service

import (
	clientsRepository "netidhub-saas-be/app/module/clients/repository"
	"netidhub-saas-be/app/module/schedules/mapper"
	"netidhub-saas-be/app/module/schedules/repository"
	"netidhub-saas-be/app/module/schedules/request"
	schedulesResponse "netidhub-saas-be/app/module/schedules/response"
	"netidhub-saas-be/utils/paginator"

	"github.com/google/uuid"
	"github.com/rs/zerolog"
)

type SchedulesService interface {
	All(clientId *uuid.UUID, req request.SchedulesQueryRequest) ([]*schedulesResponse.SchedulesResponse, *paginator.Pagination, error)
	Show(clientId *uuid.UUID, id uint) (*schedulesResponse.SchedulesResponse, error)
	Save(clientId *uuid.UUID, req request.SchedulesCreateRequest) (*schedulesResponse.SchedulesResponse, error)
	Update(clientId *uuid.UUID, id uint, req request.SchedulesUpdateRequest) error
	Delete(clientId *uuid.UUID, id uint) error
	SummaryStats(clientId *uuid.UUID) (*schedulesResponse.SchedulesSummaryStats, error)
}

type schedulesService struct {
	schedulesRepository repository.SchedulesRepository
	clientsRepository   clientsRepository.ClientsRepository
	log                 zerolog.Logger
}

func NewSchedulesService(schedulesRepository repository.SchedulesRepository, clientsRepository clientsRepository.ClientsRepository, log zerolog.Logger) SchedulesService {
	return &schedulesService{
		schedulesRepository: schedulesRepository,
		clientsRepository:   clientsRepository,
		log:                 log,
	}
}

func (_i *schedulesService) All(clientId *uuid.UUID, req request.SchedulesQueryRequest) ([]*schedulesResponse.SchedulesResponse, *paginator.Pagination, error) {
	// Handle clientSlug filter - find client by slug and set clientId
	if req.ClientSlug != nil {
		findClient, err := _i.clientsRepository.FindBySlug(*req.ClientSlug)
		if err != nil {
			_i.log.Error().Err(err).Str("clientSlug", *req.ClientSlug).Msg("Failed to find client by slug")
			return nil, nil, err
		}
		if findClient != nil {
			clientId = &findClient.ID
			_i.log.Info().Str("clientSlug", *req.ClientSlug).Str("clientId", findClient.ID.String()).Msg("Found client by slug")
		}
	}

	schedules, pagination, err := _i.schedulesRepository.All(clientId, req)
	if err != nil {
		return nil, nil, err
	}

	responses := mapper.ToSchedulesResponseList(schedules, _i.clientsRepository)
	return responses, pagination, nil
}

func (_i *schedulesService) Show(clientId *uuid.UUID, id uint) (*schedulesResponse.SchedulesResponse, error) {
	schedule, err := _i.schedulesRepository.Show(clientId, id)
	if err != nil {
		return nil, err
	}

	response := mapper.ToSchedulesResponse(schedule, _i.clientsRepository)
	return response, nil
}

func (_i *schedulesService) Save(clientId *uuid.UUID, req request.SchedulesCreateRequest) (*schedulesResponse.SchedulesResponse, error) {
	schedule := req.ToEntity()

	savedSchedule, err := _i.schedulesRepository.Save(clientId, schedule)
	if err != nil {
		return nil, err
	}

	response := mapper.ToSchedulesResponse(savedSchedule, _i.clientsRepository)
	return response, nil
}

func (_i *schedulesService) Update(clientId *uuid.UUID, id uint, req request.SchedulesUpdateRequest) error {
	schedule := req.ToEntity()

	err := _i.schedulesRepository.Update(clientId, id, schedule)
	if err != nil {
		return err
	}

	return nil
}

func (_i *schedulesService) Delete(clientId *uuid.UUID, id uint) error {
	err := _i.schedulesRepository.Delete(clientId, id)
	if err != nil {
		return err
	}

	return nil
}

func (_i *schedulesService) SummaryStats(clientId *uuid.UUID) (*schedulesResponse.SchedulesSummaryStats, error) {
	// Get today's count
	todayReq := request.SchedulesQueryRequest{}
	todayCount, err := _i.schedulesRepository.Count(clientId, todayReq)
	if err != nil {
		return nil, err
	}

	// Get this week's count
	weekReq := request.SchedulesQueryRequest{}
	weekCount, err := _i.schedulesRepository.Count(clientId, weekReq)
	if err != nil {
		return nil, err
	}

	// Get total count
	totalReq := request.SchedulesQueryRequest{}
	totalCount, err := _i.schedulesRepository.Count(clientId, totalReq)
	if err != nil {
		return nil, err
	}

	// Get live streaming count
	liveReq := request.SchedulesQueryRequest{
		IsLiveStreaming: &[]bool{true}[0],
	}
	liveCount, err := _i.schedulesRepository.Count(clientId, liveReq)
	if err != nil {
		return nil, err
	}

	// Get upcoming count (start_date > today)
	upcomingReq := request.SchedulesQueryRequest{}
	upcomingCount, err := _i.schedulesRepository.Count(clientId, upcomingReq)
	if err != nil {
		return nil, err
	}

	stats := &schedulesResponse.SchedulesSummaryStats{
		TotalToday:    int(todayCount),
		TotalThisWeek: int(weekCount),
		TotalAll:      int(totalCount),
		TotalLive:     int(liveCount),
		TotalUpcoming: int(upcomingCount),
	}

	return stats, nil
}