package services

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"thamanyah/cms/v2/internal/db"
	"time"
)

var DB DBClient

type Video struct {
	ID                string
	Title             string
	Description       string
	Categories        []string
	Tags              string
	FileName          string
	StorageKey        string
	MediaConvertJobID string
	Status            string
	SizeBytes         int64
	CreatedAt         time.Time
	UpdatedAt         time.Time
}

type DBClient interface {
	CreateVideo(ctx context.Context, v Video) (Video, error)
	ListCategories(ctx context.Context) ([]string, error)
}

type DBConcrete struct {
	SQLDB *sql.DB
}

func CreateConcreteDbClient(connectionString string) DBConcrete {
	sqlDB, err := sql.Open("postgres", connectionString)
	if err != nil {
		panic(fmt.Errorf("db: cannot open connection: %w", err))
	}
	return DBConcrete{
		SQLDB: sqlDB,
	}
}

func (svc DBConcrete) CreateVideo(ctx context.Context, v Video) (Video, error) {
	tx, err := svc.SQLDB.BeginTx(ctx, nil)
	if err != nil {
		return Video{}, err
	}
	defer tx.Rollback()

	row := tx.QueryRowContext(ctx, `
		INSERT INTO videos (title, description, tags, file_name, storage_key, mediaconvert_job_id, status, size_bytes)
		VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
		RETURNING id, created_at, updated_at
	`, v.Title, v.Description, v.Tags, v.FileName, v.StorageKey, v.MediaConvertJobID, v.Status, v.SizeBytes)

	if err := row.Scan(&v.ID, &v.CreatedAt, &v.UpdatedAt); err != nil {
		return Video{}, err
	}

	for _, category := range v.Categories {
		var categoryID int64
		if err := tx.QueryRowContext(ctx, `SELECT id FROM categories WHERE name = $1`, category).Scan(&categoryID); err != nil {
			return Video{}, fmt.Errorf("looking up category %q: %w", category, err)
		}
		if _, err := tx.ExecContext(ctx, `INSERT INTO video_categories (video_id, category_id) VALUES ($1, $2)`, v.ID, categoryID); err != nil {
			return Video{}, fmt.Errorf("linking category %q: %w", category, err)
		}
	}

	if err := tx.Commit(); err != nil {
		return Video{}, err
	}

	return v, nil
}

func (svc DBConcrete) ListCategories(ctx context.Context) ([]string, error) {
	rows, err := svc.SQLDB.QueryContext(ctx, `SELECT name FROM categories ORDER BY name`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var categories []string
	for rows.Next() {
		var name string
		if err := rows.Scan(&name); err != nil {
			return nil, err
		}
		categories = append(categories, name)
	}
	return categories, rows.Err()
}

func (svc DBConcrete) Migrate() {
	if err := db.Migrate(svc.SQLDB); err != nil {
		panic(err)
	}
}

func (svc DBConcrete) CloseConnection() {
	err := svc.SQLDB.Close()
	if err != nil {
		log.Fatalf("Error Closing DB Connection: %s", err)
	}
}

func (svc DBConcrete) AssertSuccessfulConnection(ctx context.Context) {
	if err := svc.SQLDB.PingContext(ctx); err != nil {
		panic(fmt.Errorf("db: cannot connect: %w", err))
	}
}