package task

import (
	"brainbuffer/pkg/brainbuffer/domain/appointment"
	"brainbuffer/pkg/brainbuffer/domain/repository"
	"brainbuffer/pkg/brainbuffer/domain/scheduling"
	apperrors "brainbuffer/pkg/brainbuffer/infrastructure/errors"
	"time"
)

type Service interface {
	Create(task *Task) error
	GetAllByUser(userId string, page repository.Page) (Tasks, error)
	GetByID(id int64) (*Task, error)
	DeleteByID(id int64) error
}

type defaultService struct {
	repository         Repository
	appointmentService appointment.Service
}

func NewService() Service {
	return &defaultService{
		repository:         NewRepository(),
		appointmentService: appointment.NewService(),
	}
}

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

	if task == nil {
		return nil, apperrors.NotFoundError{Message: "Task with given ID was not found."}
	}

	return task, err
}

func (serv *defaultService) Create(task *Task) error {
	if len(task.SchedulingPatterns) != 0 {
		nextTime, pattern, err := scheduling.Patterns(task.SchedulingPatterns).NextTime(time.Now())
		if err != nil {
			return apperrors.UnknownError{Err: err}
		}

		firstAppointment := appointment.Appointment{
			ID:                0,
			TaskID:            0,
			CompletionStatus:  appointment.None,
			SchedulingPattern: pattern,
			PlannedTime:       *nextTime,
			DurationOffset:    0,
			CreationTime:      time.Now(),
		}

		taskId, err := serv.repository.Save(task)
		if err != nil {
			return apperrors.UnknownError{Err: err}
		}

		firstAppointment.TaskID = taskId

		if err := serv.appointmentService.Create(&firstAppointment); err != nil {
			return err
		}
	} else {
		if _, err := serv.repository.Save(task); err != nil {
			return apperrors.UnknownError{Err: err}
		}
	}

	return nil
}

func (serv *defaultService) GetAllByUser(userId string, page repository.Page) (Tasks, error) {
	tasks, err := serv.repository.FindAllByUser(userId, page)
	if err != nil {
		return nil, apperrors.UnknownError{Err: err}
	}

	return tasks, nil
}

func (serv *defaultService) DeleteByID(id int64) error {
	if err := serv.appointmentService.DeleteAllByTask(id); err != nil {
		return err
	}

	if err := serv.repository.DeleteByID(id); err != nil {
		return apperrors.UnknownError{Err: err}
	}

	return nil
}