package main

import (
	"time"
)

type Service struct {
	Db Database
}

type DateInfo struct {
	Date      Date
	Tomorrow  Date
	Yesterday Date
	IsToday   bool
}

type EntryPage struct {
	Entry        *Entry
	Detached     bool
	Tracking     *Entry
	DateInfo     DateInfo
	GroupToTasks map[string]([]*Task)
	TaskCount    int
}

type RootPage struct {
	DateInfo DateInfo
	Entry    *EntryPage
	Entries  []*Entry
	Task     *TaskPage
	Tasks    *TasksPage
}

type TasksPage struct {
	Tasks        []*Task
	GroupToTasks map[string]([]*Task)
}

type TaskPage struct {
	Task *Task
}

func NewService(db Database) *Service {
	return &Service{
		Db: db,
	}
}

func NewDateInfo(t time.Time) DateInfo {
	return DateInfo{
		Date:      DateFromStd(t),
		Tomorrow:  DateFromStd(t.Add(24 * time.Hour)),
		Yesterday: DateFromStd(t.Add(-24 * time.Hour)),
		IsToday:   DateFromStd(time.Now()) == DateFromStd(t),
	}
}

func (srv *Service) GetTaskPage(id *int, task *Task) (*TaskPage, error) {
	if task == nil {
		tasks, err := srv.Db.QueryTask(id, nil, nil)
		if err != nil {
			return nil, err
		}
		if len(tasks) < 1 {
			return nil, ErrNotFound
		}
		task = tasks[0]
	}

	return &TaskPage{
		Task: task,
	}, nil
}

func (srv *Service) GetTasksPage() (*TasksPage, error) {
	tasks, err := srv.Db.GetTasks()
	if err != nil {
		return nil, err
	}

	mp := make(map[string]([]*Task))

	for _, task := range tasks {
		key := task.Group
		if key == nil {
			empty := ""
			key = &empty
		}
		mparr, ok := mp[*key]
		if !ok {
			mparr = make([]*Task, 0)
		}
		mparr = append(mparr, task)
		mp[*key] = mparr
	}

	return &TasksPage{
		Tasks:        tasks,
		GroupToTasks: mp,
	}, nil
}

func (srv *Service) GetEntryPage(detached *Entry, dt DateInfo) (*EntryPage, error) {
	tracking, err := srv.Db.GetTracking()
	if err != nil {
		return nil, err
	}

	tasksPage, err := srv.GetTasksPage()
	if err != nil {
		return nil, err
	}

	page := &EntryPage{
		Entry:        tracking,
		Detached:     false,
		Tracking:     tracking,
		DateInfo:     dt,
		GroupToTasks: tasksPage.GroupToTasks,
		TaskCount:    0,
	}

	if detached != nil {
		page.Entry = detached
		page.Detached = true
	}

	if page.Entry != nil {
		page.TaskCount = len(page.Entry.Tasks)
	}

	return page, nil
}

func (srv *Service) GetRootPage(date Date) (*RootPage, error) {
	var entry *Entry = nil

	if string(date) != time.Now().Format("2006-01-02") {
		// If not today detach
		entry = NewEntry(date)
	}

	entryPage, err := srv.GetEntryPage(entry, NewDateInfo(date.ToStd()))
	if err != nil {
		return nil, err
	}
	entries, err := srv.Db.QueryEntry(nil, &date)
	if err != nil {
		return nil, err
	}

	tasks, err := srv.GetTasksPage()
	if err != nil {
		return nil, err
	}

	task, err := srv.GetTaskPage(nil, NewTask())
	if err != nil {
		return nil, err
	}

	return &RootPage{
		DateInfo: entryPage.DateInfo,
		Entry:    entryPage,
		Entries:  entries,
		Task:     task,
		Tasks:    tasks,
	}, nil
}