package integration

import (
	"database/sql"
	"fmt"
	"strings"
	"testing"

	"edge-infra.dev/pkg/lib/uuid"
	"edge-infra.dev/test/f2"
	"edge-infra.dev/test/f2/x/postgres"
)

const schema = `
CREATE OR REPLACE FUNCTION trigger_set_timestamp()
    RETURNS TRIGGER AS
$$
BEGIN
    NEW.updated_at = NOW();
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TABLE IF NOT EXISTS banners (
    banner_edge_id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    banner_name text UNIQUE NOT NULL,
    project_id text UNIQUE NOT NULL,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

CREATE TABLE IF NOT EXISTS clusters (
    cluster_edge_id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
    cluster_name text NOT NULL,
    banner_edge_id UUID references banners (banner_edge_id) ON DELETE CASCADE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

CREATE TABLE IF NOT EXISTS terminals (
    terminal_id UUID default gen_random_uuid() PRIMARY KEY,
    cluster_edge_id UUID NOT NULL,
    hostname TEXT NOT NULL DEFAULT 'ien',
    FOREIGN KEY(cluster_edge_id) REFERENCES clusters(cluster_edge_id) ON DELETE CASCADE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
`

const (
	InsertIntoBanners   = `INSERT INTO banners   (banner_edge_id, banner_name, project_id)       VALUES ('%s','%s','%s');`
	InsertIntoClusters  = `INSERT INTO clusters  (cluster_edge_id, cluster_name, banner_edge_id) VALUES ('%s','%s','%s');`
	InsertIntoTerminals = `INSERT INTO terminals (terminal_id, hostname, cluster_edge_id)        VALUES ('%s','%s','%s');`
)

var UUIDs, Names = generateUUIDsAndNames()

func generateUUIDsAndNames() (map[string][]string, map[string][]string) {
	var projectUUIDs, bannerUUIDs, clusterUUIDs, terminalUUIDs []string
	var bannerNames, clusterNames, terminalNames []string
	for i := 0; i < 4; i++ {
		projectUUIDs = append(projectUUIDs, uuid.New().UUID)
		bannerUUIDs = append(bannerUUIDs, uuid.New().UUID)
		clusterUUIDs = append(clusterUUIDs, uuid.New().UUID)
		terminalUUIDs = append(terminalUUIDs, uuid.New().UUID)

		bannerNames = append(bannerNames, fmt.Sprintf("banner%d", i))
		clusterNames = append(clusterNames, fmt.Sprintf("cluster%d", i))
		terminalNames = append(terminalNames, fmt.Sprintf("terminal%d", i))
	}
	uuids := map[string][]string{
		"projects":  projectUUIDs,
		"banners":   bannerUUIDs,
		"clusters":  clusterUUIDs,
		"terminals": terminalUUIDs,
	}
	names := map[string][]string{
		"banners":   bannerNames,
		"clusters":  clusterNames,
		"terminals": terminalNames,
	}
	return uuids, names
}

var (
	Banners = []insertVals{
		{UUIDs["banners"][0], "banner0", UUIDs["projects"][0]},
		{UUIDs["banners"][1], "banner1", UUIDs["projects"][1]},
	}

	Clusters = []insertVals{
		{UUIDs["clusters"][0], "cluster0", UUIDs["banners"][0]},
		{UUIDs["clusters"][1], "cluster1", UUIDs["banners"][1]},
	}

	Terminals = []insertVals{
		{UUIDs["terminals"][0], "terminal0", UUIDs["clusters"][0]},
		{UUIDs["terminals"][1], "terminal1", UUIDs["clusters"][0]},
		{UUIDs["terminals"][2], "terminal2", UUIDs["clusters"][1]},
		{UUIDs["terminals"][3], "terminal3", UUIDs["clusters"][1]},
	}
)

type insertVals struct {
	id       string
	name     string
	parentID string
}

func CreateTables(ctx f2.Context, t *testing.T) (f2.Context, error) {
	db := postgres.FromContextT(ctx, t).DB()
	_, err := db.ExecContext(ctx, schema)
	return ctx, err
}

func PopulateTables(ctx f2.Context, db *sql.DB) (err error) {
	bannerQueries := populateQueries(InsertIntoBanners, Banners)
	err = insertIntoTable(ctx, db, bannerQueries)
	if err != nil {
		return err
	}

	clusterQueries := populateQueries(InsertIntoClusters, Clusters)
	err = insertIntoTable(ctx, db, clusterQueries)
	if err != nil {
		return err
	}

	terminalQueries := populateQueries(InsertIntoTerminals, Terminals)
	err = insertIntoTable(ctx, db, terminalQueries)
	if err != nil {
		return err
	}

	return nil
}

func populateQueries(query string, vals []insertVals) (res []string) {
	for _, val := range vals {
		res = append(res, fmt.Sprintf(query, val.id, val.name, val.parentID))
	}
	return res
}

func insertIntoTable(ctx f2.Context, db *sql.DB, queries []string) error {
	for _, query := range queries {
		_, err := db.ExecContext(ctx, query)
		if err != nil {
			return err
		}
	}
	return nil
}

func DropDatabase(ctx f2.Context, tname string) (f2.Context, error) {
	db := ctx.Value(contextVal(tname)).(*sql.DB)
	_, err := db.ExecContext(ctx, fmt.Sprintf("DROP SCHEMA %s CASCADE;", strings.ToLower(tname)))
	return ctx, err
}