package main

import (
	"fmt"
	table "git.sealight.xyz/aynish/poms/table"
	task "git.sealight.xyz/aynish/poms/task"
	timer "git.sealight.xyz/aynish/poms/timer"
	tea "github.com/charmbracelet/bubbletea"
	"github.com/charmbracelet/lipgloss"
	"log"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"time"
)

var (
	tasks   = task.GetTasks()
	columns = []table.Column{
		{Title: "ID", Width: 4},
		{Title: "Project", Width: 20},
		{Title: "Tags", Width: 20},
		{Title: "Description", Width: 35},
		// {Title: "Urgency", Width: 10},
	}

	baseStyle = lipgloss.NewStyle().
			BorderStyle(lipgloss.NormalBorder()).
			BorderForeground(lipgloss.Color("240"))
)

type model struct {
	state    string
	taskList table.Model
}

func TasksToRows(tasks []task.Task) []table.Row {
	rows := make([]table.Row, len(tasks))
	for i := 0; i < len(tasks); i++ {
		t := tasks[i]
		rows[i] = []string{strconv.Itoa(t.Id), t.Project, strings.Join(t.Tags[:], " "), t.Description} // fmt.Sprintf("%f", t.Urgency)
	}
	return rows
}

func CreateTable() table.Model {
	var t table.Model
	rows := TasksToRows(tasks)
	t = table.New(
		table.WithColumns(columns),
		table.WithRows(rows),
		table.WithFocused(true),
		table.WithHeight(15),
	)

	s := table.DefaultStyles()
	s.Header = s.Header.
		BorderStyle(lipgloss.NormalBorder()).
		BorderForeground(lipgloss.Color("240")).
		BorderBottom(true).
		Bold(false)
	s.Selected = s.Selected.
		Foreground(lipgloss.Color("229")).
		Background(lipgloss.Color("57")).
		Bold(false)
	s.Active = s.Active.
		Foreground(lipgloss.Color("0")).
		Background(lipgloss.Color("120"))
	t.SetStyles(s)
	return t
}

type editorFinishedMsg struct{ err error }

func (m model) rowsToFile() []string {
	var rows []string
	for index, row := range m.taskList.Rows() {
		if index < m.taskList.ActiveIndex() {
			// get uuid
			id := row[0]
			uuid_byte, err := exec.Command("task", "_get", id+".uuid").Output()
			if err != nil {
				log.Fatal(err)
			}
			uuid := string(uuid_byte[:len(uuid_byte)-1])

			// create task-note if it doesn't exist
			note_path := "/home/anish/kitaab/vimwiki/task-notes/" + uuid + ".wiki"
			if _, err := os.Stat(note_path); os.IsNotExist(err) {
				f, err := os.Create(note_path)
				if err != nil {
					log.Fatal(err)
				}
				path := time.Now().Format(time.DateOnly)
				tags := strings.Replace(row[2], " ", ":", -1)
				tags = ":" + row[1] + ":" + tags + ":"
				fmt.Fprintln(f, "%title "+row[3])
				fmt.Fprintln(f, tags)
				fmt.Fprintln(f, "%date "+path)
				fmt.Fprintln(f, "")
				f.Close()
			}

			// link to task-note from pom-note
			rowClone := make(table.Row, len(row))
			_ = copy(rowClone, row)
			rowClone[3] = "[[../task-notes/" + uuid + ".wiki|" + row[3] + "]]"
			rows = append(rows, strings.Join(row[1:], " - "))
		}
	}
	return rows
}

func (m model) writeFile() string {
	t := time.Now()
	var path, full_path string

	// create pom-note
	path = t.Format(time.DateOnly)
	full_path = "/home/anish/kitaab/vimwiki/poms/" + string(path) + ".wiki"
	f, err := os.Create(full_path)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()
	fmt.Fprintln(f, "%title ")
	fmt.Fprintln(f, ":pom:priv:plan:")
	fmt.Fprintln(f, "%date "+path)
	fmt.Fprintln(f, "")

	rows := m.rowsToFile()
	for _, value := range rows {
		fmt.Fprintln(f, value) // print values to f, one per line
	}
	return full_path
}

func (m model) openEditor() tea.Cmd {
	path := m.writeFile()
	editor := os.Getenv("EDITOR")
	if editor == "" {
		editor = "vim"
	}
	c := exec.Command(editor, path) //nolint:gosec
	return tea.ExecProcess(c, func(err error) tea.Msg {
		return editorFinishedMsg{err}
	})
}

// TODO
// This is where the data should be loaded...
func (m model) Init() tea.Cmd { return nil }

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmd tea.Cmd
	switch msg := msg.(type) {
	case tea.KeyMsg:
		switch msg.String() {
		case "q", "ctrl+c", "esc":
			return m, tea.Quit
		case "enter":
			return m, m.openEditor()
		}
	case tea.WindowSizeMsg:
		//top, right, bottom, left := baseStyle.GetMargin()
		m.taskList.SetWidth(msg.Width - 5)
		m.taskList.SetHeight(msg.Height - 5)
	}
	m.taskList, cmd = m.taskList.Update(msg)
	return m, cmd
}

func (m model) View() string {
	return baseStyle.Render(m.taskList.View())
}

func main() {
	var m model
	m.taskList = CreateTable()
	if _, err := tea.NewProgram(m).Run(); err != nil {
		fmt.Println("Error running program:", err)
		os.Exit(1)
	}
}