package main

import (
	"log"
	"strings"
	"os"

	"git.rdx4.com/monqui/storage/internal/storage"

	"database/sql"
	_ "github.com/mattn/go-sqlite3"
)

// Panic and crash if an error shows up, and print the error
func check(e error) {
	if e != nil {
		panic(e)
	}
}

// Convert a query into an executable statement.
func prep_query(db *sql.DB, q string) (*sql.Stmt){
	statement, err := db.Prepare(q)
	check(err)
	return statement
}

// User record management stuff.  Eventually want to abstract
// this out to store any sort of record...
type User struct {
	id   int64
	name string
}

func create_user(db *sql.DB, name string) (User) {
	s := prep_query(db, "INSERT INTO users (name) VALUES (?)")
	res, err := s.Exec(name)
	check(err)

	var u User

	id, _ := res.LastInsertId()
	u.id   = id
	u.name = name

	return u
}

func get_user(db *sql.DB, name string) (User) {
	s := prep_query(db, "SELECT * FROM users WHERE name = ? LIMIT 1")
	res, err := s.Query(name)

	check(err)

	var u User

	res.Next()
	res.Scan(&u.id, &u.name)
	res.Close()

	if u.id == 0 {
		return create_user(db, name)
	} else {
		return u
	}
}

// Blerk.  Start here with a get/create and see where
// that goes...
type Entity struct {
	id         int64
	user_id    int64
	name       string
	spawn_line string
}

func create_entity(db *sql.DB, user_id int64, name string, spawn_line string) (Entity) {
	s := prep_query(db, "INSERT INTO entities (user_id, name, spawn_line) VALUES (?, ?, ?)")
	res, err := s.Exec(user_id, name, spawn_line)
	check(err)

	var ent Entity

	id, _         := res.LastInsertId()
	ent.id         = id
	ent.user_id    = user_id
	ent.name       = name
	ent.spawn_line = spawn_line

	return ent
}

func get_entity(db *sql.DB, id int64) (Entity) {
	s := prep_query(db, "SELECT * FROM entities WHERE id = ? LIMIT 1")
	res, err := s.Query(id)

	check(err)

	var ent Entity

	res.Next()
	err = res.Scan(&ent.id, &ent.user_id, &ent.name, &ent.spawn_line)
	check(err)

	res.Close()


	if ent.id == 0 {
		log.Printf("Entity id %d doesn't exist!", id)
	}

	return ent	
}

func reset_database(db *sql.DB) {
	dat, _  := os.ReadFile("setup.sql")
	queries := strings.Split(string(dat), ";")

	for _, q := range queries {
		_, err := db.Exec(q)
		check(err)
	}
}

func main() {
	db, _ := sql.Open("sqlite3", "rpgqui.db")

	reset_database(db)

	log.Println("Reset db...\n")

  log.Println("Adding users...\n")
	// spin up a user...
	u := get_user(db, "Monqui")
log.Printf("ID: %d, name: %s", u.id, u.name)
	u  = get_user(db, "Jim")
log.Printf("ID: %d, name: %s", u.id, u.name)
	u  = get_user(db, "Monqui")
log.Printf("ID: %d, name: %s", u.id, u.name)

	// make some entities...
  log.Println("Adding entities...\n")
	e := create_entity(db, u.id, "idk a demon", "hello im monqui")
log.Printf("ID: %d, user_id: %d, spawn_line: %s", e.id, e.user_id, e.spawn_line)
  e  = create_entity(db, u.id, "idk a monster", "here's a whole nother line!")
log.Printf("ID: %d, user_id: %d, spawn_line: %s", e.id, e.user_id, e.spawn_line)

	log.Println("Trying to fetch some entities...\n")
	e  = get_entity(db, 1)
log.Printf("ID: %d, user_id: %d, spawn_line: %s", e.id, e.user_id, e.spawn_line)
	e  = get_entity(db, 2)
log.Printf("ID: %d, user_id: %d, spawn_line: %s", e.id, e.user_id, e.spawn_line)
}