package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io/ioutil"
	"net/http"
	"path/filepath"
	"regexp"
	"strings"

	"github.com/yuin/goldmark"
)

const (
	VALID_ID_REGEX = `^[0-9]+$`
)

func titleFromMd(md string) string {
	scanner := bufio.NewScanner(strings.NewReader(md))
	for scanner.Scan() {
		line := scanner.Text()
		cut, found := strings.CutPrefix(line, "# ")
		if (found) {
			return cut
		}
	}
	return "no title detected"
}

func indexGet(w http.ResponseWriter, r *http.Request) {

	cmd := "SELECT id,description_markdown FROM recipes ORDER BY id;"
	rows, err := db.Query(cmd)
	if err != nil {
		http.Error(w, "Failed to load recipes from database.", 500)
		return
	}
	defer rows.Close()

	type Element struct {
		Id    string
		Title string
		DescriptionMarkdown string
	}
	elements := make([]Element, 0)

	for rows.Next() {
		var element Element
		err := rows.Scan(&element.Id, &element.DescriptionMarkdown)
		if err != nil {
			http.Error(w, "Could not parse recipe from database request.", 500)
			return
		} else {
			element.Title = titleFromMd(element.DescriptionMarkdown)
			elements = append(elements, element)
		}
	}

	ServeTemplate(w, "index.html", elements)
}

func recipeGet(w http.ResponseWriter, r *http.Request) {

	ids := r.URL.Query()["id"]
	if len(ids) != 1 {
		msg := fmt.Sprintf("Exactly 1 'id' URL parameter expected but %d provided.", len(ids))
		http.Error(w, msg, 400)
		return
	}
	idStr := ids[0]

	idRegex := regexp.MustCompile(VALID_ID_REGEX)
	if !(idRegex.MatchString(idStr)) {
		http.Error(w, "Bad 'id' URL parameter.", 400)
		return
	}

	cmd := fmt.Sprintf("SELECT description_markdown FROM recipes WHERE (id='%s');", idStr)
	rows, err := db.Query(cmd)
	if err != nil {
		http.Error(w, "Database returned error: "+err.Error(), 500)
		return
	}
	defer rows.Close()

	type Element struct {
		Id			  string
		Title		       string
		DescriptionMarkdown	 string
		RenderedDescriptionMarkdown string
	}
	elements := make([]Element, 0)

	for rows.Next() {
		var element Element
		element.Id = idStr
		err := rows.Scan(&element.DescriptionMarkdown)
		if err != nil {
			http.Error(w, "Could not parse recipe from database request.", 500)
			return
		} else {
			element.Title = titleFromMd(element.DescriptionMarkdown)
			elements = append(elements, element)
		}
	}

	if len(elements) != 1 {
		http.Error(w, "Expected exactly 1 recipe from database.", 500)
		return
	}

	titleRegex := regexp.MustCompile(`\# .*`)
	elements[0].DescriptionMarkdown = titleRegex.ReplaceAllString(elements[0].DescriptionMarkdown, "")

	// render markdown
	var buf bytes.Buffer
	goldmark.Convert([]byte(elements[0].DescriptionMarkdown), &buf)
	elements[0].RenderedDescriptionMarkdown = buf.String()

	ServeTemplate(w, "recipe.html", elements[0])
}

func recipeEditGet(w http.ResponseWriter, r *http.Request) {

	ids := r.URL.Query()["id"]
	if len(ids) != 1 {
		http.Error(w, "Exactly 1 'id' URL parameter expected.", 400)
		return
	}
	idStr := ids[0]

	idRegex := regexp.MustCompile(VALID_ID_REGEX)
	if !(idRegex.MatchString(idStr)) {
		http.Error(w, "Bad 'id' URL parameter.", 400)
		return
	}

	cmd := fmt.Sprintf("SELECT description_markdown FROM recipes WHERE (id='%s');", idStr)
	rows, err := db.Query(cmd)
	if err != nil {
		http.Error(w, "Got error from database: "+err.Error(), 500)
		return
	}
	defer rows.Close()

	type Element struct {
		Id			  string
		DescriptionMarkdown	 string
	}
	elements := make([]Element, 0)

	for rows.Next() {
		var element Element
		element.Id = idStr
		err := rows.Scan(&element.DescriptionMarkdown)
		if err != nil {
			http.Error(w, "Could not parse recipe from database request.", 500)
			return
		} else {
			elements = append(elements, element)
		}
	}

	if len(elements) != 1 {
		http.Error(w, "Did not get exactly one recipe from database.", 500)
		return
	}

	ServeTemplate(w, "recipe_edit.html", elements[0])
}

func recipeEditPost(w http.ResponseWriter, r *http.Request) {

	ids := r.URL.Query()["id"]
	if len(ids) != 1 {
		http.Error(w, "Exactly 1 'id' URL parameter expected.", 400)
		return
	}
	idStr := ids[0]

	idRegex := regexp.MustCompile(VALID_ID_REGEX)
	if !(idRegex.MatchString(idStr)) {
		http.Error(w, "Bad 'id' URL parameter.", 400)
		return
	}

	buffer, _ := ioutil.ReadAll(r.Body) // FIXME error handling
	body := string(buffer)
	updateRecipe(body, idStr)
}

func recipeConfirmDeletionGet(w http.ResponseWriter, r *http.Request) {

	ids := r.URL.Query()["id"]
	if len(ids) != 1 {
		http.Error(w, "Exactly 1 'id' URL parameter expected.", 400)
		return
	}
	idStr := ids[0]

	type Element struct {
		Id			  string
	}
	var element Element
	element.Id = idStr

	ServeTemplate(w, "recipe_confirm_deletion.html", element)
}

func recipeConfirmDeletionPost(w http.ResponseWriter, r *http.Request) {

	ids := r.URL.Query()["id"]
	if len(ids) != 1 {
		http.Error(w, "Exactly 1 'id' URL parameter expected.", 400)
		return
	}
	idStr := ids[0]

	cmd := fmt.Sprintf("DELETE FROM recipes where (id='%s');", idStr)
	_, err := db.Query(cmd)
	if err != nil {
		fmt.Print(err)
		http.Error(w, "Could not delete recipe.", 500)
		return;
	}

	http.Redirect(w, r, "/index.html", 303)
}

func updateRecipe(body string, idStr string) {

	_, _ = db.Exec(`
		UPDATE
			recipes
		SET
			description_markdown=?
		WHERE
			(id=?);
		`,
		body, idStr,
	) // FIXME error handling

	return
}

func addRecipesGet(w http.ResponseWriter, r *http.Request) {

	cmd := fmt.Sprintf("INSERT INTO recipes (title) VALUES ('%s')", "New recipe")
	res, err := db.Exec(cmd)
	if err != nil {
		http.Error(w, "Could not create recipe.", 500)
		return
	}
	id, err := res.LastInsertId()
	if err != nil {
		http.Error(w, "Could not get new recipe ID from database", 500)
	} else {
		redirect := fmt.Sprintf("/recipe/edit?id=%d", id)
		http.Redirect(w, r, redirect, 303)
	}
}

func staticGet(w http.ResponseWriter, r *http.Request, filename string) {

	path := filepath.Join(config.Http.Static, filename)
	http.ServeFile(w, r, path)
}