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"
	. "git.andr3h3nriqu3s.com/andr3/fyp/logic/utils"
)

func handleJson(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 c.JsonBadRequest("Model not found")
	}

	type rowmodel struct {
		Name       string  `json:"name"`
		Status     int     `json:"status"`
		Id         string  `json:"id"`
		Width      *int    `json:"width"`
		Height     *int    `json:"height"`
		Color_mode *string `json:"color_mode"`
		Format     string  `json:"format"`
		Model_type int     `json:"model_type"`
	}

	var model rowmodel = rowmodel{}
	err = utils.GetDBOnce(c, &model, "models where id=$1 and user_id=$2", id, c.User.Id)
	if err == NotFoundError {
		return c.SendJSONStatus(404, "Model not found")
	} else if err != nil {
		return c.Error500(err)
	}

	return c.SendJSON(model)

	/*

		switch model.Status {
		case TRAINING:
		}
	*/
}

func handleEdit(handle *Handle) {
	handle.Get("/models/edit/classes", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
		if !CheckAuthLevel(1, w, r, c) {
			return nil
		}
		if c.Mode != JSON {
			return c.ErrorCode(nil, 400, AnyMap{})
		}

		id, err := GetIdFromUrl(r, "id")
		if err != nil {
			return c.SendJSONStatus(http.StatusNotFound, "Model not found")
		}

		model, err := GetBaseModel(c.Db, id)
		if err == ModelNotFoundError {
			return c.SendJSONStatus(http.StatusNotFound, "Model not found")
		} else if err != nil {
			return c.Error500(err)
		}

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

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

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

		type ReturnType struct {
			Classes               []*model_classes.ModelClass `json:"classes"`
			HasData               bool                        `json:"has_data"`
			NumberOfInvalidImages int                         `json:"number_of_invalid_images"`
		}

		return c.SendJSON(ReturnType{
			Classes:               cls,
			HasData:               has_data,
			NumberOfInvalidImages: wrong_number,
		})
	})

	handle.Get("/models/edit/definitions", func(w http.ResponseWriter, r *http.Request, c *Context) *Error {
		if !CheckAuthLevel(1, w, r, c) {
			return nil
		}
		if c.Mode != JSON {
			return c.ErrorCode(nil, 400, AnyMap{})
		}

		id, err := GetIdFromUrl(r, "id")
		if err != nil {
			return c.SendJSONStatus(http.StatusNotFound, "Model not found")
		}

		model, err := GetBaseModel(c.Db, id)
		if err == ModelNotFoundError {
			return c.SendJSONStatus(http.StatusNotFound, "Model not found")
		} else if err != nil {
			return c.Error500(err)
		}

		type defrow struct {
			Id            string
			Status        int
			EpochProgress int
			Epoch         int
			Accuracy      float64
		}

		defs := []defrow{}

		if model.ModelType == 2 {
			def_rows, err := c.Db.Query("select md.id, md.status, md.epoch, h.epoch_progress, h.accuracy from model_definition as md inner join exp_model_head as h on h.def_id = md.id where md.model_id=$1 order by md.created_on asc", model.Id)
			if err != nil {
				return c.Error500(err)
			}
			defer def_rows.Close()

			for def_rows.Next() {
				var def defrow
				err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
				if err != nil {
					return c.Error500(err)
				}
				defs = append(defs, def)
			}
		} else {
			def_rows, err := c.Db.Query("select id, status, epoch, epoch_progress, accuracy from model_definition where model_id=$1 order by created_on asc", model.Id)
			if err != nil {
				return c.Error500(err)
			}
			defer def_rows.Close()

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

		type layerdef struct {
			id        string
			LayerType int    `json:"layer_type"`
			Shape     string `json:"shape"`
		}

		layers := []layerdef{}

		for _, def := range defs {
			if def.Status == MODEL_DEFINITION_STATUS_TRAINING {
				rows, err := c.Db.Query("select id, layer_type, shape from model_definition_layer where def_id=$1 order by layer_order asc;", def.Id)
				if err != nil {
					return c.Error500(err)
				}
				defer rows.Close()

				for rows.Next() {
					var layerdef layerdef
					err = rows.Scan(&layerdef.id, &layerdef.LayerType, &layerdef.Shape)
					if err != nil {
						return c.Error500(err)
					}
					layers = append(layers, layerdef)
				}

				if model.ModelType == 2 {

					type lastLayerType struct {
						Id          string
						Range_start int
						Range_end   int
					}

					var lastLayer lastLayerType

					err := GetDBOnce(c, &lastLayer, "exp_model_head where def_id=$1 and status=3;", def.Id)
					if err != nil {
						return c.Error500(err)
					}

					layers = append(layers, layerdef{
						id:        lastLayer.Id,
						LayerType: LAYER_DENSE,
						Shape:     fmt.Sprintf("%d, 1", lastLayer.Range_end-lastLayer.Range_start+1),
					})
				}

				break
			}
		}

		type Definitions struct {
			Id            string      `json:"id"`
			Status        int         `json:"status"`
			EpochProgress int         `json:"epoch_progress"`
			Epoch         int         `json:"epoch"`
			Accuracy      float64     `json:"accuracy"`
			Layers        *[]layerdef `json:"layers"`
		}

		defsToReturn := make([]Definitions, len(defs), len(defs))

		setLayers := false

		for i, def := range defs {
			var lay *[]layerdef = nil
			if def.Status == MODEL_DEFINITION_STATUS_TRAINING && !setLayers {
				lay = &layers
				setLayers = true
			}
			defsToReturn[i] = Definitions{
				Id:            def.Id,
				Status:        def.Status,
				EpochProgress: def.EpochProgress,
				Epoch:         def.Epoch,
				Accuracy:      def.Accuracy,
				Layers:        lay,
			}
		}

		return c.SendJSON(defsToReturn)
	})

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

		if c.Mode == JSON {
			return handleJson(w, r, c)
		}

		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, model_type 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
			Type       int
		}

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

		err = rows.Scan(&model.Name, &model.Status, &model.Width, &model.Height, &model.Color_mode, &model.Format, &model.Type)
		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(c, 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 {
				Id            string
				Status        int
				EpochProgress int
				Epoch         int
				Accuracy      float64
			}

			defs := []defrow{}

			if model.Type == 2 {
				def_rows, err := c.Db.Query("select md.id, md.status, md.epoch, h.epoch_progress, h.accuracy from model_definition as md inner join exp_model_head as h on h.def_id = md.id where md.model_id=$1 order by md.created_on asc", model.Id)
				if err != nil {
					return c.Error500(err)
				}
				defer def_rows.Close()

				for def_rows.Next() {
					var def defrow
					err = def_rows.Scan(&def.Id, &def.Status, &def.Epoch, &def.EpochProgress, &def.Accuracy)
					if err != nil {
						return c.Error500(err)
					}
					defs = append(defs, def)
				}
			} else {
				def_rows, err := c.Db.Query("select id, status, epoch, epoch_progress, accuracy from model_definition where model_id=$1 order by created_on asc", model.Id)
				if err != nil {
					return c.Error500(err)
				}
				defer def_rows.Close()

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

			type layerdef struct {
				id        string
				LayerType int
				Shape     string
			}

			layers := []layerdef{}

			for _, def := range defs {
				if def.Status == MODEL_DEFINITION_STATUS_TRAINING {
					rows, err := c.Db.Query("select id, layer_type, shape from model_definition_layer where def_id=$1 order by layer_order asc;", def.Id)
					if err != nil {
						return c.Error500(err)
					}
					defer rows.Close()

					for rows.Next() {
						var layerdef layerdef
						err = rows.Scan(&layerdef.id, &layerdef.LayerType, &layerdef.Shape)
						if err != nil {
							return c.Error500(err)
						}
						layers = append(layers, layerdef)
					}

					if model.Type == 2 {

						type lastLayerType struct {
							Id          string
							Range_start int
							Range_end   int
						}

						var lastLayer lastLayerType

						err := GetDBOnce(c, &lastLayer, "exp_model_head where def_id=$1 and status=3;", def.Id)
						if err != nil {
							return c.Error500(err)
						}

						layers = append(layers, layerdef{
							id:        lastLayer.Id,
							LayerType: LAYER_DENSE,
							Shape:     fmt.Sprintf("%d, 1", lastLayer.Range_end-lastLayer.Range_start+1),
						})
					}

					break
				}
			}

			sep_mod := 100
			if len(layers) > 8 {
				sep_mod = 100 - (len(layers)-8)*10
			}

			if sep_mod < 10 {
				sep_mod = 10
			}

			LoadBasedOnAnswer(c.Mode, w, "/models/edit.html", c.AddMap(AnyMap{
				"Model":  model,
				"Defs":   defs,
				"Layers": layers,
				"SepMod": sep_mod,
			}))
		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
	})

}