package web

import (
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/Jaculabilis/intake/core"
	"github.com/Jaculabilis/intake/web/html"
)

func (env *Env) getSource(writer http.ResponseWriter, req *http.Request) {
	source := req.PathValue("source")
	if exists, err := core.SourceExists(env.db, source); !exists || err != nil {
		http.NotFound(writer, req)
		return
	}

	page := getQueryInt(req, "page", 1)
	count := getQueryInt(req, "count", core.DefaultFeedLimit)
	showHidden := getQueryInt(req, "hidden", 0)

	var items []core.Item
	var err error
	if showHidden != 0 {
		items, err = core.GetAllItemsForSource(env.db, source, (page-1)*count, count)
	} else {
		items, err = core.GetActiveItemsForSource(env.db, source, (page-1)*count, count)
	}
	if err != nil {
		http.Error(writer, err.Error(), 500)
		return
	}

	lastUpdated, err := core.GetLastUpdated(env.db, source)
	if err != nil {
		http.Error(writer, err.Error(), 500)
		return
	}

	data := html.FeedData{
		Items:       items,
		ShowHidden:  showHidden,
		Page:        page,
		Count:       count,
		LastUpdated: lastUpdated,
	}
	html.Feed(writer, data)
}

func (env *Env) fetchSource(writer http.ResponseWriter, req *http.Request) {
	source := req.PathValue("source")
	if exists, err := core.SourceExists(env.db, source); !exists || err != nil {
		http.NotFound(writer, req)
		return
	}

	state, envs, argv, postProcess, err := core.GetSourceActionInputs(env.db, source, "fetch")
	if err != nil {
		http.Error(writer, fmt.Sprintf("error: failed to get data for %s: %v", source, err.Error()), 500)
		return
	}

	items, newState, errItem, err := core.Execute(source, argv, envs, state, "", time.Minute, postProcess)
	if err != nil {
		core.AddErrorItem(env.db, errItem)
		http.Error(writer, fmt.Sprintf("error: failed to execute fetch: %v", err.Error()), 500)
		return
	}

	added, deleted, err := core.UpdateWithFetchedItems(env.db, source, newState, items, time.Now())
	if err != nil {
		http.Error(writer, fmt.Sprintf("error: failed to update: %v", err.Error()), 500)
		return
	}
	log.Printf("%s added %d items, updated %d items, and deleted %d items", source, added, len(items)-added, deleted)

	data := html.FetchData{
		Source:  source,
		Added:   added,
		Updated: len(items) - added,
		Deleted: deleted,
		Items:   items,
	}
	html.Fetch(writer, data)
}

func (env *Env) getEditSource(writer http.ResponseWriter, req *http.Request) {
	source := req.PathValue("source")
	if exists, err := core.SourceExists(env.db, source); !exists || err != nil {
		http.NotFound(writer, req)
		return
	}

	envs, err := core.GetEnvsMap(env.db, source)
	if err != nil {
		http.Error(writer, err.Error(), 500)
		return
	}

	actions, _ := core.GetActionsForSource(env.db, source)
	argvs := make(map[string]string)
	for _, action := range actions {
		argv, _ := core.GetArgvForAction(env.db, source, action)
		args, _ := Quote(argv)
		argvs[action] = args
	}

	data := html.EditSourceData{
		Name:    source,
		Envs:    envs,
		Actions: argvs,
	}
	html.EditSource(writer, data)
}

func (env *Env) editSource(writer http.ResponseWriter, req *http.Request) {
	source := req.PathValue("source")
	if exists, err := core.SourceExists(env.db, source); !exists || err != nil {
		http.NotFound(writer, req)
		return
	}

	if err := req.ParseForm(); err != nil {
		http.Error(writer, err.Error(), 400)
		return
	}

	envName := req.PostForm.Get("envName")
	envValue := req.PostForm.Get("envValue")
	if envName != "" {
		log.Printf("setting %s=%s", envName, envValue)
		if err := core.SetEnvs(env.db, source, []string{fmt.Sprintf("%s=%s", envName, envValue)}); err != nil {
			http.Error(writer, err.Error(), 500)
			return
		}
		if envName == "INTAKE_CRON" {
			specs, err := core.GetCronSources(env.db)
			if err != nil {
				log.Printf("error: failed to get cron specs: %v", err)
			} else {
				err = core.UpdateCrontab(env.db, specs)
				if err != nil {
					log.Printf("error: failed to update crontab: %v", err)
				}
			}
		}
	}

	actionName := req.PostForm.Get("actionName")
	actionArgv := req.PostForm.Get("actionArgv")
	if actionName != "" {
		log.Printf("setting %s -- %s", actionName, actionArgv)
		if actionArgv == "" {
			if err := core.DeleteAction(env.db, source, actionName); err != nil {
				http.Error(writer, err.Error(), 500)
				return
			}
		} else {
			argv, err := Shlex(actionArgv)
			if err != nil {
				http.Error(writer, err.Error(), 400)
				return
			}
			if err = core.SetAction(env.db, source, actionName, argv); err != nil {
				http.Error(writer, err.Error(), 500)
				return
			}
		}
	}

	writer.Header()["HX-Refresh"] = []string{"true"}
	writer.WriteHeader(http.StatusNoContent)
}