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 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
		}

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

		err = rows.Scan(&model.Name, &model.Status, &model.Width, &model.Height, &model.Color_mode)
		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 int
            }

            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
	})
}