package main

import (
	"database/sql"
	"errors"
	"fmt"
	"math/rand"
	"os"
	"os/user"
	"strings"
	"time"

	"git.tilde.town/tildetown/town/models"
	//"git.tilde.town/tildetown/town/review"
	"git.tilde.town/tildetown/town/signup"
	tuser "git.tilde.town/tildetown/town/user"
	"github.com/gdamore/tcell/v2"
	"github.com/rivo/tview"
)

func getTitle() string {
	titles := []string{
		"yo bum rush the show",
		"can i kick it?",
		"super nintendo sega genesis",
		"birthdays was the worst days",
		"where were you when we were getting high?",
		"it's real time, real time, time to get real",
	}
	return titles[rand.Intn(len(titles))]
}

// TODO affordance for cleaning up email response

type reviewer struct {
	db        *sql.DB
	adminName string
}

func newReviewer(db *sql.DB, adminName string) *reviewer {
	return &reviewer{db: db, adminName: adminName}
}

func (r *reviewer) Review(s *models.TownSignup, decision models.SignupDecision) error {
	s.DecisionTime = time.Now()
	s.Decision = decision
	s.DecidedBy = r.adminName
	return s.Review(r.db)
}

func (r *reviewer) AddNote(s *models.TownSignup, content string) error {
	note := &models.SignupNote{
		Author:   r.adminName,
		Content:  content,
		SignupID: s.ID,
	}

	return note.Insert(r.db)
}

func renderSignup(s models.TownSignup) string {
	out := ""

	pairs := [][]string{
		{"submitted", s.Created.Format("2006-01-02 15:04")},
		{"e-mail", s.Email},
		{"how found / referral", s.How},
		{"why like town / plans", s.Why},
		{"links", s.Links},
	}

	for _, v := range pairs {
		out += fmt.Sprintf("[-:-:b]%s[-:-:-]\n", v[0])
		out += strings.TrimSpace(v[1])
		out += "\n\n"
	}

	return out
}

func renderNotes(s models.TownSignup) string {
	out := ""
	for _, note := range s.Notes {
		out += fmt.Sprintf(`%s said on %s:
  %s`, note.Author, note.Created.Format("2006-01-02 15:04"), note.Content)

		out += "\n\n"

	}
	return out
}

func _main() error {
	/*
		TODO will use this for invites
		userDB, err := review.ConnectDB()
		if err != nil {
			return fmt.Errorf("could not connect to user database: %w", err)
		}
	*/

	signupDB, err := signup.ConnectDB()
	if err != nil {
		return fmt.Errorf("could not connect to signups database: %w", err)
	}

	u, err := user.Current()
	if err != nil {
		return fmt.Errorf("that's my purse. I don't know you! %w", err)
	}
	isAdmin, err := tuser.IsAdmin(u)
	if err != nil {
		return fmt.Errorf("that's my purse. I don't know you! %w", err)
	}

	if !isAdmin {
		return errors.New("this command can only be run by a town admin")
	}

	r := newReviewer(signupDB, u.Username)

	rand.Seed(time.Now().Unix())

	su := models.TownSignup{}

	signups, err := su.All(signupDB)
	if err != nil {
		return fmt.Errorf("could not fetch signups: %w", err)
	}

	signupIx := 0

	title := tview.NewTextView()
	title.SetText(getTitle())
	title.SetTextAlign(tview.AlignCenter)
	title.SetTextColor(tcell.ColorPurple)
	title.SetBackgroundColor(tcell.ColorBlack)

	appView := tview.NewTextView()
	appView.SetDynamicColors(true)

	legend := tview.NewTextView()
	legend.SetText("s: skip r: random A: approve R: reject N: notate Q: quit")
	legend.SetTextColor(tcell.ColorPurple)
	legend.SetTextAlign(tview.AlignCenter)
	legend.SetBackgroundColor(tcell.ColorBlack)

	count := tview.NewTextView()
	count.SetDynamicColors(true)
	updateCount := func() {
		plural := "s"
		if len(signups) == 1 {
			plural = ""
		}
		count.SetText(fmt.Sprintf("[-:-:b]%d pending signup%s[-:-:-]", len(signups), plural))
	}
	updateCount()

	notesView := tview.NewTextView()
	notesView.SetDynamicColors(true)
	notesView.SetBorder(true).SetBorderColor(tcell.ColorPurple)

	bottomFlex := tview.NewFlex()
	bottomFlex.SetDirection(tview.FlexColumn)
	bottomFlex.AddItem(count, 0, 1, false)
	bottomFlex.AddItem(legend, 0, 10, false)

	innerFlex := tview.NewFlex()
	innerFlex.SetDirection(tview.FlexColumn)
	innerFlex.AddItem(appView, 0, 2, true)
	innerFlex.AddItem(notesView, 0, 1, true)

	mainFlex := tview.NewFlex()
	mainFlex.SetDirection(tview.FlexRow)
	mainFlex.AddItem(title, 1, -1, false)
	mainFlex.AddItem(innerFlex, 0, 1, false)
	mainFlex.AddItem(bottomFlex, 1, -1, false)

	pages := tview.NewPages()

	errorModal := tview.NewModal()
	errorModal.AddButtons([]string{"damn"})
	errorModal.SetDoneFunc(func(ix int, _ string) {
		pages.SwitchToPage("main")
	})

	render := func() {
		if len(signups) == 0 {
			appView.SetText("no signups")
			return
		}
		currSignup := signups[signupIx]
		err := currSignup.RefreshNotes(signupDB)
		if err != nil {
			errorModal.SetText(fmt.Sprintf("error! failed to add note: %s", err.Error()))
			pages.SwitchToPage("error")
		}

		appView.SetText(renderSignup(*currSignup))
		notesView.SetText(renderNotes(*currSignup))
	}

	render()

	notate := tview.NewForm()
	notate.AddTextArea("note", "", 80, 10, 1000, func(string) {})
	notate.AddButton("submit", func() {
		fi := notate.GetFormItemByLabel("note").(*tview.TextArea)
		err = r.AddNote(signups[signupIx], fi.GetText())
		if err != nil {
			errorModal.SetText(fmt.Sprintf("error! failed to add note: %s", err.Error()))
			pages.SwitchToPage("error")
			return
		}

		render()

		pages.SwitchToPage("main")
	})
	notate.AddButton("cancel", func() {
		pages.SwitchToPage("main")
	})

	reviewModal := tview.NewFlex().SetDirection(tview.FlexRow)

	providedEmailView := tview.NewTextView()
	providedEmailView.SetTitle("provided email input")

	reviewForm := tview.NewForm()
	decisionFI := tview.NewDropDown().SetLabel("decision")
	decisionFI.SetOptions([]string{"accepted", "rejected"}, func(_ string, _ int) {})

	cleanEmailInput := tview.NewInputField()
	cleanEmailInput.SetLabel("clean email")
	cleanEmailInput.SetAcceptanceFunc(func(tx string, _ rune) bool { return len(tx) > 0 })

	reviewForm.AddFormItem(decisionFI)
	reviewForm.AddFormItem(cleanEmailInput)
	reviewForm.AddButton("submit", func() {
		currSignup := signups[signupIx]
		cleanEmail := reviewForm.GetFormItemByLabel("clean email").(*tview.InputField).GetText()
		currSignup.CleanEmail = cleanEmail

		decision := models.SignupRejected
		_, d := reviewForm.GetFormItemByLabel("decision").(*tview.DropDown).GetCurrentOption()
		if d == "accepted" {
			decision = models.SignupAccepted
		}

		err := r.Review(currSignup, decision)
		if err != nil {
			errorModal.SetText(fmt.Sprintf("error! failed to submit review: %s", err.Error()))
			pages.SwitchToPage("error")
			return
		}

		newSignups := []*models.TownSignup{}
		for ix, s := range signups {
			if ix != signupIx {
				newSignups = append(newSignups, s)
			}
		}
		signups = newSignups
		if len(signups) > 0 {
			if signupIx >= len(signups) {
				signupIx = 0
			}
		}
		updateCount()
		render()
		if decision == models.SignupAccepted {
			// TODO generate invite token
			// TODO send invite email
		}
		pages.SwitchToPage("main")
	})
	reviewForm.AddButton("cancel", func() {
		pages.SwitchToPage("main")
	})

	reviewModal.AddItem(tview.NewTextView().SetText("provided email input"), 1, 1, false)
	reviewModal.AddItem(providedEmailView, 0, 1, false)
	reviewModal.AddItem(reviewForm, 0, 1, true)

	pages.AddPage("main", mainFlex, true, true)
	pages.AddPage("error", errorModal, false, false)
	pages.AddPage("notate", notate, true, false)
	pages.AddPage("review", reviewModal, true, false)

	app := tview.NewApplication()
	app.SetRoot(pages, true)

	app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
		currPage, _ := pages.GetFrontPage()
		if currPage == "notate" {
			return event
		}
		switch event.Rune() {
		case 's':
			signupIx++
			if signupIx == len(signups) {
				signupIx = 0
			}
			render()
		case 'r':
			if len(signups) > 0 {
				signupIx = rand.Intn(len(signups))
				render()
			}
		case 'A':
			if len(signups) == 0 {
				return nil
			}
			providedEmailView.SetText(signups[signupIx].Email)
			decisionFI.SetCurrentOption(0)
			pages.SwitchToPage("review")
			app.SetFocus(cleanEmailInput)
		case 'R':
			if len(signups) == 0 {
				return nil
			}
			providedEmailView.SetText(signups[signupIx].Email)
			decisionFI.SetCurrentOption(1)
			pages.SwitchToPage("review")
		case 'N':
			if len(signups) == 0 {
				return nil
			}
			pages.SwitchToPage("notate")
			return nil
		case 'Q':
			app.Stop()
		}

		return event
	})

	return app.Run()
}

func main() {
	err := _main()
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}