package maindb

import (
	"context"
	"path/filepath"

	"mbase/pkg/logger"

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

const schema = `
    --- DROP TABLE IF EXISTS account;
    CREATE TABLE IF NOT EXISTS account (
	id          TEXT  NOT NULL,
	username    TEXT NOT NULL,
	passhash    TEXT NOT NULL,
        created_at  TEXT NOT NULL,
        updated_at  TEXT NOT NULL,
        disabled    BOOL
    );
    CREATE UNIQUE INDEX IF NOT EXISTS account_index01
        ON account(id);
    CREATE UNIQUE INDEX IF NOT EXISTS account_index02
        ON account(username);

    --- DROP TABLE IF EXISTS grant;
    CREATE TABLE IF NOT EXISTS grant (
	id          TEXT NOT NULL,
        account_id  TEXT NOT NULL,
	operation   TEXT NOT NULL,
        created_at  TEXT NOT NULL
    );
    CREATE INDEX IF NOT EXISTS grant_index01
        ON grant(account_id);
    CREATE UNIQUE INDEX IF NOT EXISTS grant_index02
        ON grant(account_id, operation);
`

type Database struct {
	datapath string
	db       *sqlx.DB
	log      *logger.Logger
}

func NewDatabase(datapath string) (*Database, error) {
	var err error
	db := &Database{
		datapath: datapath,
	}
	db.log = logger.NewLogger("database")
	return db, err

}

func (db *Database) OpenDatabase() error {
	var err error
	dbPath := filepath.Join(db.datapath, "main.db")
	db.db, err = sqlx.Open("sqlite3", dbPath)
	if err != nil {
		return err
	}

	err = db.db.Ping()
	if err != nil {
		return err
	}
	return err
}

func (db *Database) InitDatabase() error {
	var err error
	_, err = db.db.Exec(schema)
	if err != nil {
		return err
	}
	return err
}

func (db *Database) CleanDatabase(ctx context.Context) error {
	var err error

	request := `
                DELETE FROM account;
                DELETE FROM grant;
        `
	_, err = db.db.Exec(request)
	if err != nil {
		return err
	}
	return err
}