package appointment

import (
	apperrors "brainbuffer/pkg/brainbuffer/errors"
	"brainbuffer/pkg/brainbuffer/repository"
	"time"
)

var taskNotFoundError = apperrors.NotFoundError{Message: "Task with given ID was not found."}

type Service interface {
	Create(appointment *Appointment) error
	CreateNextAppointment(appointment *Appointment) error
	GetByID(id int64) (*Appointment, error)
	GetAllByTask(taskId int64, page repository.Page) (Appointments, error)
	GetAllByTasks(tasksIds []int64, page repository.Page) (Appointments, error)
	GetAllByTasksBefore(tasksIds []int64, beforeTime time.Time, page repository.Page) (Appointments, error)
	DeleteAllByTask(taskId int64) error
}

type defaultService struct {
	repository Repository
}

func NewService() Service {
	return &defaultService{repository: NewRepository()}
}

func (service *defaultService) Create(appointment *Appointment) error {
	appointment.CreationTime = time.Now()

	if err := service.repository.Save(appointment); err != nil {
		return apperrors.UnknownError{Err: err}
	}

	return nil
}

func (service *defaultService) CreateNextAppointment(appointment *Appointment) error {
	nextTime, err := appointment.SchedulingPattern.NextTime(appointment.Time)
	if err != nil {
		return apperrors.UnknownError{Err: err}
	}

	nextAppointment := Appointment{
		ID:                0,
		TaskID:            appointment.TaskID,
		Status:            Upcoming,
		SchedulingPattern: appointment.SchedulingPattern,
		Time:              *nextTime,
		DurationOffset:    0,
		CreationTime:      time.Now(),
	}

	if err := service.Create(&nextAppointment); err != nil {
		return err
	}

	return nil
}

func (service *defaultService) GetByID(id int64) (*Appointment, error) {
	a, err := service.repository.FindByID(id)
	if err != nil {
		return nil, apperrors.UnknownError{Err: err}
	}

	if a == nil {
		return nil, taskNotFoundError
	}

	return a, nil
}

func (service *defaultService) GetAllByTask(taskId int64, page repository.Page) (Appointments, error) {
	appointments, err := service.repository.GetAllByTask(taskId, page)
	if err != nil {
		return nil, apperrors.UnknownError{Err: err}
	}

	return appointments, nil
}

func (service *defaultService) GetAllByTasks(tasksIds []int64, page repository.Page) (Appointments, error) {
	appointments, err := service.repository.GetAllByTasks(tasksIds, page)
	if err != nil {
		return nil, apperrors.UnknownError{Err: err}
	}

	return appointments, nil
}

func (service *defaultService) GetAllByTasksBefore(tasksIds []int64, beforeTime time.Time, page repository.Page) (Appointments, error) {
	appointments, err := service.repository.GetAllByTasksBefore(tasksIds, beforeTime, page)
	if err != nil {
		return nil, apperrors.UnknownError{Err: err}
	}

	return appointments, nil
}

func (service *defaultService) DeleteAllByTask(taskId int64) error {
	if err := service.repository.DeleteAllByTask(taskId); err != nil {
		return apperrors.UnknownError{Err: err}
	}

	return nil
}