package models

import (
	"github.com/gisle/stufflog/internal/generate"
	"github.com/gisle/stufflog/slerrors"
	"time"
)

// A Period is a chunk of time in which activities should be performed. They should always be created manually.
type Period struct {
	ID     string    `json:"id"`
	UserID string    `json:"userId"`
	From   time.Time `json:"from"`
	To     time.Time `json:"to"`
	Name   string    `json:"name"`

	ShouldReScore bool `json:"-" msgpack:"-"`

	Goals []Goal `json:"goals"`
	Logs  []Log  `json:"logs"`
}

// GenerateIDs generates IDs. It should only be used initially.
func (period *Period) GenerateIDs() {
	period.ID = generate.ID("P", 12)
	for i := range period.Goals {
		period.Goals[i].ID = generate.ID("PG", 16)
	}
	for i := range period.Logs {
		period.Logs[i].ID = generate.ID("PL", 16)
	}
}

// Clear clears the period, but doesn't re-alloc the slices if they're set.
func (period *Period) Clear() {
	period.ID = ""
	period.UserID = ""
	period.From = time.Time{}
	period.To = time.Time{}
	period.Name = ""

	period.ShouldReScore = false

	period.Goals = period.Goals[:0]
	period.Logs = period.Logs[:0]
}

// Copy makes a deep copy of the period.
func (period *Period) Copy() *Period {
	periodCopy := *period

	periodCopy.Goals = make([]Goal, len(period.Goals))
	copy(periodCopy.Goals, period.Goals)
	periodCopy.Logs = make([]Log, len(period.Logs))
	copy(periodCopy.Logs, period.Logs)

	return &periodCopy
}

// IncludesDate returns true if the date is within the interval of SetFrom..SetTo.
func (period *Period) IncludesDate(date time.Time) bool {
	return (date == period.From || date == period.To) || (date.After(period.From) && date.Before(period.To))
}

// ApplyUpdate applies an update. It does not calculate/validate the scores or remote IDs.
//
// It may still have been changed even if it errors.
func (period *Period) ApplyUpdate(update PeriodUpdate) (changed bool, err error) {
	if update.SetFrom != nil {
		changed = true
		period.From = *update.SetFrom
	}
	if update.SetTo != nil {
		changed = true
		period.To = *update.SetTo
	}
	if update.SetName != nil {
		changed = true
		period.Name = *update.SetName
	}

	if update.AddGoal != nil {
		goal := *update.AddGoal
		goal.ID = generate.ID("PG", 16)

		for _, existingGoal := range period.Goals {
			if existingGoal.ActivityID == goal.ActivityID {
				return false, slerrors.PreconditionFailed("Activity already exists in another goal.")
			}
		}

		period.Goals = append(period.Goals, goal)

		if update.AddLog != nil && update.AddLog.GoalID == "NEW" {
			update.AddLog.GoalID = goal.ID
		}

		changed = true
	}
	if update.ReplaceGoal != nil {
		goal := period.Goal(update.ReplaceGoal.ID)
		if goal == nil {
			err = slerrors.NotFound("Goal")
			return
		}

		goal.PointCount = update.ReplaceGoal.PointCount

		changed = true
		period.ShouldReScore = true
	}
	if update.RemoveGoal != nil {
		found := false
		for i, goal := range period.Goals {
			if goal.ID == *update.RemoveGoal {
				period.Goals = append(period.Goals[:i], period.Goals[i+1:]...)
				found = true
				break
			}
		}
		if !found {
			err = slerrors.NotFound("Goal you're trying to remove")
			return
		}

		changed = true
		period.ShouldReScore = true
	}

	if update.AddLog != nil {
		log := *update.AddLog
		log.ID = generate.ID("L", 16)
		log.SubmitTime = time.Now()

		goal := period.Goal(log.GoalID)
		if goal == nil {
			err = slerrors.NotFound("Goal")
			return
		}

		period.Logs = append(period.Logs, log)
		changed = true
	}
	if update.ReplaceLog != nil {
		log := *update.ReplaceLog

		found := false
		for i, log2 := range period.Logs {
			if log.ID == log2.ID {
				found = true

				goal := period.Goal(log.GoalID)
				if goal == nil {
					err = slerrors.NotFound("Goal")
					return
				}

				period.Logs[i] = log
				break
			}
		}

		if !found {
			err = slerrors.NotFound("Log")
			return
		}
	}
	if update.RemoveLog != nil {
		found := false
		for i, log := range period.Logs {
			if log.ID == *update.RemoveLog {
				found = true
				changed = true
				period.Logs = append(period.Logs[:i], period.Logs[i+1:]...)

				break
			}
		}
		if !found {
			err = slerrors.NotFound("Log you're trying to remove")
			return
		}
	}

	return
}

func (period *Period) RemoveBrokenLogs() {
	goodLogs := make([]Log, 0, len(period.Logs))

	for _, log := range period.Logs {
		goal := period.Goal(log.GoalID)
		if goal == nil {
			continue
		}

		goodLogs = append(goodLogs, log)
	}

	period.Logs = goodLogs
}

func (period *Period) Goal(id string) *Goal {
	for i, goal := range period.Goals {
		if goal.ID == id {
			return &period.Goals[i]
		}
	}

	return nil
}

func (period *Period) DayHadActivity(date time.Time, activityID string) bool {
	date = date.UTC().Truncate(time.Hour * 24)

	if !period.IncludesDate(date) {
		return false
	}

	for _, log := range period.Logs {
		goal := period.Goal(log.GoalID)
		if goal == nil || goal.ActivityID != activityID {
			continue
		}

		if date.Equal(log.Date.UTC().Truncate(time.Hour * 24)) {
			return true
		}
	}

	return false
}

// PeriodUpdate describes a change to a period
type PeriodUpdate struct {
	SetFrom *time.Time `json:"setFrom"`
	SetTo   *time.Time `json:"setTo"`
	SetName *string    `json:"setName"`

	AddLog      *Log    `json:"addLog"`
	ReplaceLog  *Log    `json:"replaceGoal"`
	RemoveLog   *string `json:"removeLog"`
	AddGoal     *Goal   `json:"addGoal"`
	ReplaceGoal *Goal   `json:"replaceGoal"`
	RemoveGoal  *string `json:"removeGoal"`
}

type Score struct {
	ActivityScore  float64  `json:"activityScore"`
	Amount         int      `json:"amount"`
	ItemMultiplier *float64 `json:"subGoalMultiplier"`
	DailyBonus     int      `json:"dailyBonus"`

	Total int64 `json:"total"`
}

func (s *Score) Calc() {
	subGoalMultiplier := 1.0
	if s.ItemMultiplier != nil {
		subGoalMultiplier = *s.ItemMultiplier
	}

	s.Total = int64(s.DailyBonus) + int64(s.ActivityScore*float64(s.Amount)*subGoalMultiplier)
}

type PeriodsByFrom []*Period

func (periods PeriodsByFrom) Len() int {
	return len(periods)
}

func (periods PeriodsByFrom) Less(i, j int) bool {
	return periods[i].From.Before(periods[j].From)
}

func (periods PeriodsByFrom) Swap(i, j int) {
	periods[i], periods[j] = periods[j], periods[i]
}