package sqlgenerate

import (
	_ "embed"
	"strings"

	"github.com/jinzhu/inflection"
	"github.com/jmoiron/sqlx"
	_ "github.com/mattn/go-sqlite3"
)

func InitDB(sql_schema string) *sqlx.DB {
	db := sqlx.MustOpen("sqlite3", ":memory:")
	db.MustExec(sql_schema)
	db.MustExec(`
		create temporary view tables as
		    select l.schema, l.name, l.type, l.ncol, l.wr, l.strict
		      from sqlite_schema s
		 left join pragma_table_list l on s.name = l.name
		     where s.type = 'table';

		create temporary view columns as
		    select tables.name as table_name,
		           table_info.name as column_name,
		           lower(table_info.type) as column_type,
		           "notnull",
	               dflt_value is not null as has_default_value,
		           ifnull(dflt_value, 0) dflt_value,
		           pk as is_primary_key,
       	           fk."table" is not null as is_foreign_key,
		           ifnull(fk."table", '') as fk_target_table,
		           ifnull(fk."to", '') as fk_target_column
		      from tables
		      join pragma_table_info(tables.name) as table_info
		 left join pragma_foreign_key_list(tables.name) as fk on fk."from" = column_name;
	`)
	return db
}

// SchemaFromDB takes a DB connection, checks its schema metadata tables, and returns a Schema.
func SchemaFromDB(db *sqlx.DB) Schema {
	return ParseSchema(db)
}
func ParseSchema(db *sqlx.DB) Schema {
	ret := Schema{}

	var table_list []string
	err := db.Select(&table_list, `select name from tables`)
	if err != nil {
		panic(err)
	}

	for _, table_name := range table_list {
		tbl := Table{TableName: table_name}
		tbl.TypeName = snakeToCamel(inflection.Singular(table_name))
		tbl.TypeIDName = tbl.TypeName + "ID"
		tbl.VarName = strings.ToLower(string(table_name[0]))

		err := db.Select(&tbl.Columns, `select * from columns where table_name = ?`, table_name)
		if err != nil {
			panic(err)
		}
		ret[tbl.TableName] = tbl
	}
	return ret
}

func snakeToCamel(s string) string {
	parts := strings.Split(s, "_")
	for i := 0; i < len(parts); i++ {
		parts[i] = strings.ToUpper(string(parts[i][0])) + parts[i][1:]
	}
	return strings.Join(parts, "")
}