package database

import (
	"context"
	"path/filepath"

	"certmanager/pkg/logger"

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

const schema = `
    --- DROP TABLE IF EXISTS issuer;
    CREATE TABLE IF NOT EXISTS issuer (
	id          INT  NOT NULL,
	name        TEXT NOT NULL,
	cert        TEXT NOT NULL,
	key         TEXT,
	signer_id   INT  NOT NULL,
	signer_name TEXT NOT NULL,
	revoked     BOOL
    );
    CREATE UNIQUE INDEX IF NOT EXISTS issuer_index01
        ON issuer(id);
    CREATE UNIQUE INDEX IF NOT EXISTS issuer_index02
        ON issuer(name);

    --- DROP TABLE IF EXISTS service;
    CREATE TABLE IF NOT EXISTS service (
	id          INT  NOT NULL,
        issuer_id   INT  NOT NULL,
        issuer_name TEXT NOT NULL,
	name        TEXT NOT NULL,
	cert        TEXT NOT NULL,
	key         TEXT NOT NULL,
	revoked     BOOL
    );
    CREATE UNIQUE INDEX IF NOT EXISTS service_index01
        ON service(id);
    CREATE UNIQUE INDEX IF NOT EXISTS service_index02
        ON service(name);

    --- DROP TABLE IF EXISTS account;
    CREATE TABLE IF NOT EXISTS account (
	id          INT  NOT NULL,
	username    TEXT NOT NULL,
	password    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          INT  NOT NULL,
        account_id  INT  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) InitDatabase(ctx context.Context) error {
	var err error
	dbPath := filepath.Join(db.datapath, "certmanager.db")
	db.log.Infof("Initialize database %s", dbPath)

	db.db, err = sqlx.Open("sqlite3", dbPath)
	if err != nil {
		return err
	}

	err = db.db.Ping()
	if err != nil {
		return err
	}
	_, 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 issuer;
                DELETE FROM service;
                DELETE FROM account;
                DELETE FROM grant;
        `
	_, err = db.db.Exec(request)
	if err != nil {
		return err
	}
	return err
}