package main

import (
	"errors"
	"fmt"
	"gitea.seeseepuff.be/seeseemelk/mysqlite"
	"github.com/gin-gonic/gin"
	"net/http"
	"strconv"
	"strings"
)

type App struct {
	db *mysqlite.Db
}

func (a *App) postCreateDevice(c *gin.Context) {
	qr, err := strconv.Atoi(c.PostForm("asset-qr"))
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("invalid qr: %v", err))
	}

	tx, err := a.db.Begin()
	defer tx.MustRollback()
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error beginning tx: %v", err))
		return
	}

	err = a.DeleteAsset(tx, qr)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error removing assets: %v", err))
		return
	}

	// Insert the asset into the database
	var id int
	err = a.createAsset("asset", tx, c, &id)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error inserting asset: %v", err))
		return
	}
	assetType := c.PostForm("asset-type")
	err = a.createAsset(assetType, tx, c, &id)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error inserting asset type: %v", err))
		return
	}

	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	err = tx.Commit()
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}
	c.Redirect(http.StatusSeeOther, "/")
}

func (a *App) createAsset(assetType string, tx *mysqlite.Tx, c *gin.Context, assetId *int) error {
	for _, assetDescriptor := range DescriptorTree.AssetTypes {
		if assetDescriptor.Id != assetType {
			continue
		}

		var fields []string
		var questions []string
		var values []string

		for _, field := range assetDescriptor.Fields {
			fields = append(fields, field.Id)
			questions = append(questions, "?")
			values = append(values, c.PostForm(assetType+"-"+field.Id))
		}

		if *assetId != 0 {
			fields = append(fields, "asset")
			questions = append(questions, "?")
			values = append(values, strconv.Itoa(*assetId))
		}

		fieldsStr := strings.Join(fields, ", ")
		questionsStr := strings.Join(questions, ", ")
		err := tx.Query(fmt.Sprintf("INSERT INTO %s (%s) values (%s)", assetDescriptor.Table, fieldsStr, questionsStr)).
			Bind(values).
			Exec()
		if err != nil {
			return err
		}

		if *assetId == 0 {
			err := tx.Query("SELECT LAST_INSERT_ROWID()").ScanSingle(assetId)
			if err != nil {
				return fmt.Errorf("error getting last insert id: %v", err)
			}
		}

		return nil
	}
	return errors.New("Create Asset not implemented for type: " + assetType)
}

func (a *App) postCreateDeviceRam(c *gin.Context, qr int, tx *mysqlite.Tx) error {
	var err error
	capacity := 0
	capacityString := c.PostForm("ram_capacity")
	if capacityString != "" {
		capacity, err = strconv.Atoi(c.PostForm("ram_capacity"))
		if err != nil {
			return err
		}
	}
	switch c.PostForm("ram_capacity_unit") {
	case "B":
	case "KB":
		capacity *= 1024
	case "MB":
		capacity *= 1024 * 1024
	case "GB":
		capacity *= 1024 * 1024 * 1024
	default:
		return errors.New("invalid ram_capacity_unit")
	}

	err = tx.Query("INSERT INTO info_ram (asset, type, capacity) VALUES (?, ?, ?)").
		Bind(qr, c.PostForm("ram_type"), capacity).Exec()
	return err
}

func (a *App) postCreateDeviceHdd(c *gin.Context, qr int, tx *mysqlite.Tx) error {
	var err error
	capacity := 0
	capacityString := c.PostForm("hdd_capacity")
	if capacityString != "" {
		capacity, err = strconv.Atoi(c.PostForm("hdd_capacity"))
		if err != nil {
			return err
		}
	}
	switch c.PostForm("hdd_capacity_unit") {
	case "B":
	case "KB":
		capacity *= 1024
	case "MB":
		capacity *= 1024 * 1024
	case "GB":
		capacity *= 1024 * 1024 * 1024
	default:
		return errors.New("invalid hdd_capacity_unit")
	}

	err = tx.Query("INSERT INTO info_hdd (asset, capacity, type, form_factor, connection, rpm) VALUES (?, ?, ?, ?, ?, ?)").
		Bind(qr, capacity, c.PostForm("hdd_type"), c.PostForm("hdd_form_factor"), c.PostForm("hdd_connection"), c.PostForm("hdd_rpm")).
		Exec()
	return err
}

type BrowseVM struct {
	Assets []Asset
	HasRam bool
}

type Asset struct {
	Qr            int
	Name          string
	Brand         string
	Type          string
	Description   string
	RamType       string
	RamCapacity   int
	HddCapacity   int
	HddType       string
	HddFormFactor string
	HddConnection string
	HddRpm        int
}

func (a *App) getBrowse(c *gin.Context) {
	brands := c.QueryArray("brand")
	types := c.QueryArray("type")

	query := `SELECT assets.qr, assets.name, assets.brand, assets.type, assets.description,
    			info_ram.type, info_ram.capacity,
				info_hdd.capacity, info_hdd.type, info_hdd.form_factor, info_hdd.connection, info_hdd.rpm
				FROM assets 
				LEFT JOIN info_ram ON info_ram.asset = assets.qr
				LEFT JOIN info_hdd ON info_hdd.asset = assets.qr
				WHERE 1=1`
	if len(brands) > 0 {
		query += " AND assets.brand IN (" + placeholders(len(brands)) + ")"
	}
	if len(types) > 0 {
		query += " AND assets.type IN (" + placeholders(len(types)) + ")"
	}
	query += "ORDER BY assets.type, assets.brand, assets.name, assets.qr"

	vm := &BrowseVM{}

	var err error
	q := a.db.Query(query).Bind(brands, types)
	for row := range q.Range(&err) {
		var asset Asset
		err := row.Scan(&asset.Qr, &asset.Name, &asset.Brand, &asset.Type, &asset.Description,
			&asset.RamType, &asset.RamCapacity,
			&asset.HddCapacity, &asset.HddType, &asset.HddFormFactor, &asset.HddConnection, &asset.HddRpm)
		if err != nil {
			c.AbortWithError(http.StatusInternalServerError, err)
			return
		}
		vm.Assets = append(vm.Assets, asset)
		if asset.Type == "ram" {
			vm.HasRam = true
		}
	}
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	c.HTML(http.StatusOK, "browse", vm)
}

type DeleteVM struct {
	Qr int
}

func (a *App) getDelete(c *gin.Context) {
	qr, err := strconv.Atoi(c.Query("id"))
	if err != nil {
		c.AbortWithError(http.StatusBadRequest, fmt.Errorf("invalid qr: %v", err))
		return
	}
	vm := &DeleteVM{Qr: qr}
	c.HTML(http.StatusOK, "delete", vm)
}

func (a *App) postDelete(c *gin.Context) {
	qr, err := strconv.Atoi(c.Query("id"))
	if err != nil {
		c.AbortWithError(http.StatusBadRequest, fmt.Errorf("invalid qr: %v", err))
		return
	}
	tx, err := a.db.Begin()
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	err = a.DeleteAsset(tx, qr)
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}

	err = tx.Commit()
	if err != nil {
		c.AbortWithError(http.StatusInternalServerError, err)
		return
	}
	c.Redirect(http.StatusSeeOther, "/")
}

func placeholders(count int) string {
	if count == 0 {
		return ""
	}
	placeholder := "?"
	for count > 1 {
		placeholder += ", ?"
		count--
	}
	return placeholder
}