package main

//go:generate sh -c "printf 'package main\n\nconst version = \"'%s'\"\n' $(git describe --tags --abbrev=0) > version.go"

import (
	"flag"
	"fmt"
	"github.com/go-jet/jet/v2/internal/utils/errfmt"
	"github.com/go-jet/jet/v2/internal/utils/strslice"
	"os"
	"strings"

	"github.com/go-jet/jet/v2/generator/metadata"
	sqlitegen "github.com/go-jet/jet/v2/generator/sqlite"
	"github.com/go-jet/jet/v2/generator/template"
	"github.com/go-jet/jet/v2/internal/jet"
	"github.com/go-jet/jet/v2/mysql"
	postgres2 "github.com/go-jet/jet/v2/postgres"
	"github.com/go-jet/jet/v2/sqlite"

	mysqlgen "github.com/go-jet/jet/v2/generator/mysql"
	postgresgen "github.com/go-jet/jet/v2/generator/postgres"
	_ "github.com/go-sql-driver/mysql"
	_ "github.com/lib/pq"
	_ "github.com/mattn/go-sqlite3"
)

var (
	source string

	dsn        string
	host       string
	port       int
	user       string
	password   string
	sslmode    string
	params     string
	dbName     string
	schemaName string

	ignoreTables string
	ignoreViews  string
	ignoreEnums  string

	destDir  string
	modelPkg string
	tablePkg string
	viewPkg  string
	enumPkg  string
)

func init() {
	flag.StringVar(&source, "source", "", "Database system name (postgres, mysql, cockroachdb, mariadb or sqlite)")

	flag.StringVar(&dsn, "dsn", "", `Data source name. Unified format for connecting to database.
    	PostgreSQL: https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING
		Example:
			postgresql://user:pass@localhost:5432/dbname
    	MySQL: https://dev.mysql.com/doc/refman/8.0/en/connecting-using-uri-or-key-value-pairs.html
		Example:
			mysql://jet:jet@tcp(localhost:3306)/dvds
    	SQLite: https://www.sqlite.org/c3ref/open.html#urifilenameexamples
		Example:
			file://path/to/database/file`)
	flag.StringVar(&host, "host", "", "Database host path. Used only if dsn is not set. (Example: localhost)")
	flag.IntVar(&port, "port", 0, "Database port. Used only if dsn is not set.")
	flag.StringVar(&user, "user", "", "Database user. Used only if dsn is not set.")
	flag.StringVar(&password, "password", "", "The user’s password. Used only if dsn is not set.")
	flag.StringVar(&dbName, "dbname", "", "Database name. Used only if dsn is not set.")
	flag.StringVar(&schemaName, "schema", "public", `Database schema name. (default "public")(PostgreSQL only)`)
	flag.StringVar(&params, "params", "", "Additional connection string parameters(optional). Used only if dsn is not set.")
	flag.StringVar(&sslmode, "sslmode", "disable", `Whether or not to use SSL. Used only if dsn is not set. (optional)(default "disable")(PostgreSQL only)`)
	flag.StringVar(&ignoreTables, "ignore-tables", "", `Comma-separated list of tables to ignore.`)
	flag.StringVar(&ignoreViews, "ignore-views", "", `Comma-separated list of views to ignore.`)
	flag.StringVar(&ignoreEnums, "ignore-enums", "", `Comma-separated list of enums to ignore.`)

	flag.StringVar(&destDir, "path", "", "Destination directory for files generated.")
	flag.StringVar(&modelPkg, "model-pkg", "model", "Relative path for the Model files package from the destination directory.")
	flag.StringVar(&tablePkg, "table-pkg", "table", "Relative path for the Table files package from the destination directory.")
	flag.StringVar(&viewPkg, "view-pkg", "view", "Relative path for the View files package from the destination directory.")
	flag.StringVar(&enumPkg, "enum-pkg", "enum", "Relative path for the Enum files package from the destination directory.")
}

func main() {
	flag.Usage = usage
	flag.Parse()

	if dsn == "" && (source == "" || host == "" || port == 0 || user == "" || dbName == "") {
		printErrorAndExit("ERROR: required flag(s) missing")
	}

	source := getSource()
	ignoreTablesList := parseList(ignoreTables)
	ignoreViewsList := parseList(ignoreViews)
	ignoreEnumsList := parseList(ignoreEnums)

	var err error

	switch source {
	case "postgresql", "postgres", "cockroachdb", "cockroach":
		generatorTemplate := genTemplate(postgres2.Dialect, ignoreTablesList, ignoreViewsList, ignoreEnumsList)

		if dsn != "" {
			err = postgresgen.GenerateDSN(dsn, schemaName, destDir, generatorTemplate)
			break
		}

		dbConn := postgresgen.DBConnection{
			Host:     host,
			Port:     port,
			User:     user,
			Password: password,
			SslMode:  sslmode,
			Params:   params,

			DBName:     dbName,
			SchemaName: schemaName,
		}

		err = postgresgen.Generate(
			destDir,
			dbConn,
			generatorTemplate,
		)

	case "mysql", "mysqlx", "mariadb":
		generatorTemplate := genTemplate(mysql.Dialect, ignoreTablesList, ignoreViewsList, ignoreEnumsList)

		if dsn != "" {
			err = mysqlgen.GenerateDSN(dsn, destDir, generatorTemplate)
			break
		}

		dbConn := mysqlgen.DBConnection{
			Host:     host,
			Port:     port,
			User:     user,
			Password: password,
			Params:   params,
			DBName:   dbName,
		}

		err = mysqlgen.Generate(
			destDir,
			dbConn,
			generatorTemplate,
		)
	case "sqlite":
		if dsn == "" {
			printErrorAndExit("ERROR: required -dsn flag missing.")
		}

		err = sqlitegen.GenerateDSN(
			dsn,
			destDir,
			genTemplate(sqlite.Dialect, ignoreTablesList, ignoreViewsList, ignoreEnumsList),
		)

	case "":
		printErrorAndExit("ERROR: required -source or -dsn flag missing.")

	default:
		printErrorAndExit("ERROR: unknown data source " + source + ". Only postgres, mysql, mariadb and sqlite are supported.")
	}

	if err != nil {
		fmt.Println(errfmt.Trace(err))
		os.Exit(2)
	}
}

func usage() {
	fmt.Println("Jet generator", version)
	fmt.Println()
	fmt.Println("Usage:")

	order := []string{
		"source", "dsn", "host", "port", "user", "password", "dbname", "schema", "params", "sslmode",
		"path",
		"ignore-tables", "ignore-views", "ignore-enums",
		"model-pkg", "table-pkg", "view-pkg", "enum-pkg",
	}

	for _, name := range order {
		flagEntry := flag.CommandLine.Lookup(name)
		fmt.Printf("  -%s\n", flagEntry.Name)
		fmt.Printf("\t%s\n", flagEntry.Usage)
	}

	fmt.Println()
	fmt.Println(`Example commands:

	$ jet -dsn=postgresql://jet:jet@localhost:5432/jetdb?sslmode=disable -schema=dvds -path=./gen
	$ jet -dsn=postgres://jet:jet@localhost:26257/jetdb?sslmode=disable -schema=dvds -path=./gen   #cockroachdb
	$ jet -source=postgres -dsn="user=jet password=jet host=localhost port=5432 dbname=jetdb" -schema=dvds -path=./gen
	$ jet -source=mysql -host=localhost -port=3306 -user=jet -password=jet -dbname=jetdb -path=./gen
	$ jet -source=sqlite -dsn="file://path/to/sqlite/database/file" -path=./gen
	$ jet -source=sqlite -dsn="file://path/to/sqlite/database/file" -path=./gen -model-pkg=./entity
	`)
}

func printErrorAndExit(error string) {
	fmt.Println("\n", error)
	fmt.Println()
	flag.Usage()
	os.Exit(1)
}

func getSource() string {
	if source != "" {
		return strings.TrimSpace(strings.ToLower(source))
	}

	return detectSchema(dsn)
}

func detectSchema(dsn string) string {
	match := strings.SplitN(dsn, "://", 2)
	if len(match) < 2 { // not found
		return ""
	}

	protocol := match[0]

	if protocol == "file" {
		return "sqlite"
	}

	return strings.ToLower(match[0])
}

func parseList(list string) []string {
	ret := strings.Split(list, ",")

	for i := 0; i < len(ret); i++ {
		ret[i] = strings.ToLower(strings.TrimSpace(ret[i]))
	}

	return ret
}

func genTemplate(dialect jet.Dialect, ignoreTables []string, ignoreViews []string, ignoreEnums []string) template.Template {

	shouldSkipTable := func(table metadata.Table) bool {
		return strslice.Contains(ignoreTables, strings.ToLower(table.Name))
	}

	shouldSkipView := func(view metadata.Table) bool {
		return strslice.Contains(ignoreViews, strings.ToLower(view.Name))
	}

	shouldSkipEnum := func(enum metadata.Enum) bool {
		return strslice.Contains(ignoreEnums, strings.ToLower(enum.Name))
	}

	return template.Default(dialect).
		UseSchema(func(schemaMetaData metadata.Schema) template.Schema {
			return template.DefaultSchema(schemaMetaData).
				UseModel(template.DefaultModel().UsePath(modelPkg).
					UseTable(func(table metadata.Table) template.TableModel {
						if shouldSkipTable(table) {
							return template.TableModel{Skip: true}
						}
						return template.DefaultTableModel(table)
					}).
					UseView(func(view metadata.Table) template.ViewModel {
						if shouldSkipView(view) {
							return template.ViewModel{Skip: true}
						}
						return template.DefaultViewModel(view)
					}).
					UseEnum(func(enum metadata.Enum) template.EnumModel {
						if shouldSkipEnum(enum) {
							return template.EnumModel{Skip: true}
						}
						return template.DefaultEnumModel(enum)
					}),
				).
				UseSQLBuilder(template.DefaultSQLBuilder().
					UseTable(func(table metadata.Table) template.TableSQLBuilder {
						if shouldSkipTable(table) {
							return template.TableSQLBuilder{Skip: true}
						}

						return template.DefaultTableSQLBuilder(table).UsePath(tablePkg)
					}).
					UseView(func(table metadata.Table) template.ViewSQLBuilder {
						if shouldSkipView(table) {
							return template.ViewSQLBuilder{Skip: true}
						}

						return template.DefaultViewSQLBuilder(table).UsePath(viewPkg)
					}).
					UseEnum(func(enum metadata.Enum) template.EnumSQLBuilder {
						if shouldSkipEnum(enum) {
							return template.EnumSQLBuilder{Skip: true}
						}

						return template.DefaultEnumSQLBuilder(enum).UsePath(enumPkg)
					}),
				)
		})
}