package lists

import (
	"database/sql"
	"fagott.pw/charakterin"
	"fagott.pw/grilist/frontend"
	"fagott.pw/grilist/grilist"
	"fagott.pw/grilist/modules/grils"
	"fmt"
	"log"
	"time"
)

// Module und so.
type Module struct {
	g     *grilist.Grilist
	grils *grils.GrilsModule
}

// List ist eine Liste an DINGEN.
type List struct {
	ID          int
	Name        string
	Description string
	Owner       *charakterin.User
	ForkOf      int
	UpdatedAt   time.Time
}

// Name gibt den Namen des Moduls zurück
func (m *Module) Name() string {
	return "Lists"
}

// Init initialisiert das Modul
func (m *Module) Init(g *grilist.Grilist) {
	m.g = g

	gm, ok := g.Modules["Grils"]
	if !ok {
		log.Fatal("lists: grils module not found")
	}

	grilsModule, ok := gm.Interface().(*grils.GrilsModule)
	if !ok {
		log.Fatal("lists: error with grils module")
	}
	m.grils = grilsModule
}

// Interface gibt das Modul zurück
func (m *Module) Interface() interface{} {
	return m
}

// GetUserLists gibt die Listen eines Benutzers zurück.
func (m *Module) GetUserLists(u *charakterin.User) []*List {
	var lists []*List

	rows, err := m.g.DB.Query(`SELECT id, name, description, fork_of, updated_at FROM grilist.lists WHERE user_id = $1`, u.ID)
	if err != nil {
		return lists
	}

	defer rows.Close()
	for rows.Next() {
		list := &List{}

		if err := rows.Scan(&list.ID, &list.Name, &list.Description, &list.ForkOf, &list.UpdatedAt); err != nil {
			log.Println("error scanning row", err)
			continue
		}

		lists = append(lists, list)
	}

	return lists
}

func mkCard(title, description string, actions ...frontend.Action) frontend.Card {
	card := frontend.Card{
		Title:       title,
		Description: description,
		Size:        "medium",
	}

	for _, action := range actions {
		card.Actions = append(card.Actions, action)
	}

	return card
}

func rowsToCard(rows *sql.Rows) []frontend.Card {
	var cards []frontend.Card

	for rows.Next() {
		var id int
		var title, description string
		if err := rows.Scan(&id, &title, &description); err != nil {
			log.Println("error scanning row", err)
			continue
		}

		cards = append(cards, mkCard(title, description, frontend.Action{"anguckieren", fmt.Sprintf("/lists/%d", id)}))
	}
	return cards
}

// ProvideDashboardData gibt Daten für das Dashboard bezogen auf den Benutzer zurück
func (m *Module) ProvideDashboardData(user *charakterin.User) []grilist.DashboardCategory {
	var categories []grilist.DashboardCategory

	// Listen des Benutzers
	rows, err := m.g.DB.Query(`SELECT id, name, description FROM grilist.lists WHERE user_id = $1`, user.ID)
	if err != nil {
		log.Println(err)
		return []grilist.DashboardCategory{}
	}
	defer rows.Close()

	categories = append(categories, grilist.DashboardCategory{
		Title: "Meine Listen",
		Cards: rowsToCard(rows),
	})

	// Neue Listen
	rows, err = m.g.DB.Query(`SELECT id, name, description FROM grilist.lists ORDER BY id DESC LIMIT 5`)
	if err != nil {
		log.Println(err)
		return categories
	}
	defer rows.Close()

	categories = append(categories, grilist.DashboardCategory{
		Title: "Neueste Listen",
		Cards: rowsToCard(rows),
	})

	return categories
}

// New erstellt eine neue Instanz des Modules
func New() *Module {
	return &Module{}
}