package domain

import (
	"fmt"
	"time"
)

const (
	tribeIDMin = 1
)

type Monitor struct {
	ID        string
	TribeID   int64
	GroupID   string
	CreatedAt time.Time
}

type MonitorWithTribe struct {
	Monitor
	Tribe TribeMeta
}

type CreateMonitorParams struct {
	tribeID int64
	groupID string
}

func NewCreateMonitorParams(groupID string, tribeID int64) (CreateMonitorParams, error) {
	if groupID == "" {
		return CreateMonitorParams{}, ValidationError{
			Field: "GroupID",
			Err:   ErrRequired,
		}
	}

	if tribeID < tribeIDMin {
		return CreateMonitorParams{}, ValidationError{
			Field: "TribeID",
			Err: MinError{
				Min: tribeIDMin,
			},
		}
	}

	return CreateMonitorParams{tribeID: tribeID, groupID: groupID}, nil
}

func (c CreateMonitorParams) TribeID() int64 {
	return c.tribeID
}

func (c CreateMonitorParams) GroupID() string {
	return c.groupID
}

type MonitorAlreadyExistsError struct {
	TribeID int64
	GroupID string
}

func (e MonitorAlreadyExistsError) Error() string {
	return fmt.Sprintf("monitor (GroupID=%s,TribeID=%d) already exists", e.GroupID, e.TribeID)
}

func (e MonitorAlreadyExistsError) UserError() string {
	return e.Error()
}

func (e MonitorAlreadyExistsError) Code() ErrorCode {
	return ErrorCodeAlreadyExists
}

type MonitorLimitReachedError struct {
	Current int // current number of groups
	Limit   int // maximum number of groups
}

func (e MonitorLimitReachedError) Error() string {
	return fmt.Sprintf("monitor limit has been reached (%d/%d)", e.Current, e.Limit)
}

func (e MonitorLimitReachedError) UserError() string {
	return e.Error()
}

func (e MonitorLimitReachedError) Code() ErrorCode {
	return ErrorCodeValidationError
}

type MonitorNotFoundError struct {
	ID string
}

func (e MonitorNotFoundError) Error() string {
	return fmt.Sprintf("monitor (ID=%s) not found", e.ID)
}

func (e MonitorNotFoundError) UserError() string {
	return e.Error()
}

func (e MonitorNotFoundError) Code() ErrorCode {
	return ErrorCodeEntityNotFound
}