package main

import (
	"database/sql"
	"log"
	"time"
)

// DataType : holds information about a specific DataType
type DataType struct {
	ID        int       `json:"id"`
	DataType  string    `json:"dataType"`
	PlcType   string    `json:"plcType"`
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

// DataTypes : a list of DataType items
type DataTypes []DataType

const dataTypeTableCreationQuery = `CREATE TABLE IF NOT EXISTS dataTypes (
	id int(10) unsigned AUTO_INCREMENT,
	dataType varchar(255),
	plcType varchar(255),
	createdAt datetime,
	updatedAt datetime,
	UNIQUE KEY dataType (dataType),
	PRIMARY KEY (id)
  )`

func ensureDataTypeTableExists(db *sql.DB) {
	if _, err := db.Exec(dataTypeTableCreationQuery); err != nil {
		log.Fatal(err)
	}
}
func seedDataTypeData(db *sql.DB) {
	sqlQuery := `INSERT INTO dataTypes VALUES 
		(1,'Floating Point','REAL','2016-10-13 15:05:32','2016-10-13 15:05:32'),
		(2,'Integer','INT','2016-10-13 15:05:32','2016-10-13 15:05:32'),
		(3,'Boolean','BOOL','2016-10-13 15:05:32','2016-10-13 15:05:32');`
	insStmt, insErr := db.Prepare(sqlQuery)

	if insErr != nil {
		panic(insErr.Error()) // proper error handling instead of panic in your app
	}
	defer insStmt.Close() // Close the statement when we leave main() / the program terminates

	insStmt.Exec()
}

// getDataType : used during GET command
func (c *DataType) getDataType(db *sql.DB) error {
	return db.QueryRow("SELECT dataType, plcType, createdAt, updatedAt FROM dataTypes WHERE id=?", c.ID).Scan(&c.DataType, &c.PlcType, &c.CreatedAt, &c.UpdatedAt)
}

// updateDataType : used during PUT command
func (c *DataType) updateDataType(db *sql.DB) error {
	updStmt, updErr := db.Prepare("UPDATE dataTypes SET dataType=?, plcType=?, updatedAt=? WHERE id=?")
	if updErr != nil {
		panic(updErr.Error()) // proper error handling instead of panic in your app
	}
	defer updStmt.Close() // Close the statement when we leave main() / the program terminates

	_, err := updStmt.Exec(c.DataType, c.PlcType, time.Now(), c.ID)
	return err
}

// deleteDataType : used during DELETE command
func (c *DataType) deleteDataType(db *sql.DB) error {
	_, err := db.Exec("DELETE FROM dataTypes WHERE id=?", c.ID)
	return err
}

// createDataType : used during PUSH command
func (c *DataType) createDataType(db *sql.DB) error {
	stmtIns, insErr := db.Prepare("INSERT INTO dataTypes (dataType, plcType, createdAt, updatedAt) VALUES (?, ?, ?, ?);")
	if insErr != nil {
		panic(insErr.Error()) // proper error handling instead of panic in your app
	}
	defer stmtIns.Close() // Close the statement when we leave main() / the program terminates

	_, err := stmtIns.Exec(c.DataType, c.PlcType, time.Now(), time.Now())
	return err
}

// getDataTypes : used during GET command for all
func getDataTypes(db *sql.DB, start, count int) (DataTypes, error) {
	rows, err := db.Query(
		"SELECT id, dataType, plcType, createdAt, updatedAt FROM dataTypes LIMIT ? OFFSET ?",
		count, start)

	if err != nil {
		return nil, err
	}

	defer rows.Close()

	dataTypes := DataTypes{}

	for rows.Next() {
		var c DataType
		if err := rows.Scan(&c.ID, &c.DataType, &c.PlcType, &c.CreatedAt, &c.UpdatedAt); err != nil {
			return nil, err
		}
		dataTypes = append(dataTypes, c)
	}

	return dataTypes, nil
}