tasks.go

package main

import (
	"encoding/json"
	"errors"
	"io"
	"log"
	"os"
	"slices"
	"strconv"
	"time"
)

type Task struct {
	Title     string    `json:"title"`
	Deadline  time.Time `json:"deadline"`
	CreatedAt time.Time `json:"createdAt"`
	Info      []rune    `json:"info"`
	isDone    bool
}

func NewTask(TitleN string, DeadlineN time.Time, CreatedAtN time.Time, InfoN []rune) Task {
	return Task{Title: TitleN, Deadline: DeadlineN, CreatedAt: CreatedAtN, Info: InfoN}
}

func (a *App) ReadSave() {
	file, err := os.Open(a.saveFilePath)

	if errors.Is(err, os.ErrNotExist) {
		a.taskSlice = []Task{}
		return
	} else if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	decoder := json.NewDecoder(file)
	if err := decoder.Decode(&a.taskSlice); err != nil {
		if err == io.EOF {
			a.taskSlice = []Task{}
			return
		}
		log.Fatal(err)
	}
}

func (a *App) WriteSave() {
	newSlice := []Task{}
	for _, current := range a.taskSlice {
		if !current.isDone {
			newSlice = append(newSlice, current)
		}
	}

	file, err := os.Create(a.saveFilePath)
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	encoder := json.NewEncoder(file)
	encoder.SetIndent("", "  ")
	if err := encoder.Encode(newSlice); err != nil {
		log.Fatal(err)
	}
}

func (a *App) SortTasks() {
	slices.SortFunc(a.taskSlice, func(a, b Task) int {
		if a.Deadline.Before(b.Deadline) {
			return -1
		} else if a.Deadline.After(b.Deadline) {
			return 1
		}
		return 0
	})
}

func (a *App) CompleteTasks(taskIndex int) {
	a.taskSlice[taskIndex].isDone = !a.taskSlice[taskIndex].isDone
}

func (a *App) InitDisplayedTasks() {
	for range a.taskSlice {
		a.disLast++
		if a.disLast == 6 {
			break
		}
	}
	a.displayedTasks = a.taskSlice[a.disFirst:a.disLast]
}

func (a *App) IncrementDisplayedTasks() {
	if len(a.taskSlice) > a.disLast {
		a.disFirst++
		a.disLast++
		a.displayedTasks = a.taskSlice[a.disFirst:a.disLast]
	}
}

func (a *App) LowerDisplayedTasks() {
	if a.disFirst > 0 {
		a.disFirst--
		a.disLast--
		a.displayedTasks = a.taskSlice[a.disFirst:a.disLast]
	}
}

func (t *taskMenu) AddTask(a *App, edit bool) {
	stringHours := string(t.inputHours)
	stringDays := string(t.inputDays)

	intHours, err := strconv.Atoi(stringHours)
	if err != nil {
		intHours = 0
	}

	intDays, err := strconv.Atoi(stringDays)
	if err != nil {
		intDays = 0
	}

	finalTime := intHours + 24*intDays

	stringFinal := strconv.Itoa(finalTime) + "h"
	duration, err := time.ParseDuration(stringFinal)
	if err != nil {
		return
	}

	addedTask := NewTask(string(t.inputTitle), time.Now().Add(duration), time.Now(), t.inputInfo)

	if edit {
		a.taskSlice[a.disFirst+a.cursorPos-1] = addedTask
		a.SortTasks()
		a.displayedTasks = a.taskSlice[a.disFirst:a.disLast]
	} else {
		a.taskSlice = append(a.taskSlice, addedTask)
		a.SortTasks()
		if len(a.taskSlice) <= 6 {
			a.disLast++
		}
		a.displayedTasks = a.taskSlice[a.disFirst:a.disLast]
	}
}

func (a *App) LoadEditMenu(taskIndex int) {
	for _, r := range a.taskSlice[taskIndex].Title {
		a.TaskMenu.inputTitle = append(a.TaskMenu.inputTitle, r)
	}

	duration := a.taskSlice[taskIndex].Deadline.Sub(a.taskSlice[taskIndex].CreatedAt)
	days := int(duration.Hours()) / 24
	hours := int(duration.Hours()) % 24

	daysString := strconv.Itoa(days)
	hoursString := strconv.Itoa(hours)

	for _, r := range daysString {
		a.TaskMenu.inputDays = append(a.TaskMenu.inputDays, r)
	}

	for _, r := range hoursString {
		a.TaskMenu.inputHours = append(a.TaskMenu.inputHours, r)
	}

	a.TaskMenu.inputInfo = a.taskSlice[taskIndex].Info
}