package models

import (
	"fmt"
	"net/http"

	model_classes "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/classes"
	. "git.andr3h3nriqu3s.com/andr3/fyp/logic/models/utils"
	. "git.andr3h3nriqu3s.com/andr3/fyp/logic/utils"
)

func handleEdit(handle *Handle) {
	handle.GetHTML("/models/edit", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
		if !CheckAuthLevel(1, w, r, c) {
			return nil
		}

		id, err := GetIdFromUrl(r, "id")
		if err != nil {
			return ErrorCode(nil, http.StatusNotFound, AnyMap{
				"NotFoundMessage": "Model not found",
				"GoBackLink":      "/models",
			})
		}

		// TODO handle admin users
		rows, err := handle.Db.Query("select name, status, width, height, color_mode, format from models where id=$1 and user_id=$2;", id, c.User.Id)
		if err != nil {
			return Error500(err)
		}
		defer rows.Close()

		if !rows.Next() {
			return ErrorCode(nil, http.StatusNotFound, AnyMap{
				"NotFoundMessage": "Model not found",
				"GoBackLink":      "/models",
			})
		}

		type rowmodel struct {
			Name       string
			Status     int
			Id         string
			Width      *int
			Height     *int
			Color_mode *string
			Format     string
		}

		var model rowmodel = rowmodel{}
		model.Id = id

		err = rows.Scan(&model.Name, &model.Status, &model.Width, &model.Height, &model.Color_mode, &model.Format)
		if err != nil {
			return Error500(err)
		}

		// Handle errors
		// All errors will be negative
		if model.Status < 0 {
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
			return nil
		}

		switch model.Status {
		case PREPARING:
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
		case CONFIRM_PRE_TRAINING:

			wrong_number, err := model_classes.GetNumberOfWrongDataPoints(c.Db, model.Id)
			if err != nil {
				return c.Error500(err)
			}

			cls, err := model_classes.ListClasses(handle.Db, id)
			if err != nil {
				return c.Error500(err)
			}

			has_data, err := model_classes.ModelHasDataPoints(handle.Db, id)
			if err != nil {
				return Error500(err)
			}

			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model":                 model,
				"Classes":               cls,
				"HasData":               has_data,
				"NumberOfInvalidImages": wrong_number,
			}))
		case READY:
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
		case TRAINING:

			type defrow struct {
				Status        int
				EpochProgress int
				Accuracy      float64
			}

			def_rows, err := c.Db.Query("select status, epoch_progress, accuracy from model_definition where model_id=$1", model.Id)
			if err != nil {
				return c.Error500(err)
			}
			defer def_rows.Close()

			defs := []defrow{}

			for def_rows.Next() {
				var def defrow
				err = def_rows.Scan(&def.Status, &def.EpochProgress, &def.Accuracy)
				if err != nil {
					return c.Error500(err)
				}
				defs = append(defs, def)
			}

			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
				"Defs":  defs,
			}))
		case PREPARING_ZIP_FILE:
			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model": model,
			}))
		default:
			fmt.Printf("Unkown Status: %d\n", model.Status)
			return Error500(nil)
		}

		return nil
	})
}