package programs

import (
	"context"
	"database/sql"
	"errors"
	"fmt"
	"net/url"
	"os/exec"
	"strings"

	"alin.ovh/x/log"
	"github.com/Southclaws/fault"
	"github.com/Southclaws/fault/fmsg"
	"modernc.org/sqlite"

	"alin.ovh/searchix/internal/config"
	"alin.ovh/searchix/internal/file"
)

type DB struct {
	source config.Source
	logger *log.Logger
	root   *file.Root
	db     *sql.DB
	stmt   *sql.Stmt
}

type Options struct {
	Logger *log.Logger
	Root   *file.Root
}

func New(source config.Source, options *Options) (*DB, error) {
	return &DB{
		source: source,

		logger: options.Logger,
		root:   options.Root,
	}, nil
}

func (p *DB) Instantiate(ctx context.Context) error {
	// nix-instantiate --eval --json -I nixpkgs=channel:nixos-unstable --expr 'toString <nixpkgs/programs.sqlite>'
	args := []string{
		"--eval",
		"--json",
		"-I", fmt.Sprintf("%s=channel:%s", p.source.Key, p.source.Channel),
		"--expr", fmt.Sprintf("toString <%s/%s>", p.source.Key, p.source.Programs.Attribute),
	}

	p.logger.Debug("nix-instantiate command", "args", args)
	cmd := exec.CommandContext(ctx, "nix-instantiate", args...)
	out, err := cmd.Output()
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to run nix-instantiate"))
	}

	outPath := strings.Trim(strings.TrimSpace(string(out)), "\"")
	p.logger.Debug("got output path", "outputPath", outPath)

	p.db, err = p.openDB("rwc")
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to open sqlite database"))
	}

	_, err = p.db.ExecContext(ctx, "DROP TABLE IF EXISTS programs")
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to drop programs table"))
	}

	_, err = p.db.ExecContext(
		ctx,
		"ATTACH DATABASE ? AS input",
		(&url.URL{
			Scheme: "file",
			Path:   outPath,
			RawQuery: url.Values{
				"immutable": {"1"},
			}.Encode(),
		}).String(),
	)
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to attach nix-store programs database"))
	}

	_, err = p.db.ExecContext(ctx, `
CREATE TABLE programs AS
SELECT name, package
FROM input.Programs
GROUP BY name, package
`)
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to create programs table"))
	}
	p.logger.Debug("created programs table")

	_, err = p.db.ExecContext(ctx, `CREATE INDEX idx_package ON programs(package)`)
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to create idx_package index"))
	}
	p.logger.Debug("created idx_package index")

	_, err = p.db.ExecContext(ctx, "DETACH DATABASE input")
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to detach nix-store programs database"))
	}

	return nil
}

func (p *DB) openDB(mode string) (*sql.DB, error) {
	u := fmt.Sprintf(
		"file:%s?mode=%s&_pragma=foreign_keys(1)&_pragma=mmap_size(%d)",
		//nolint: forbidigo // external package
		p.root.JoinPath(p.source.JoinFilePath("programs.db")),
		mode,
		16*1024*1024,
	)

	db, err := sql.Open("sqlite", u)
	if err != nil {
		var sqliteErr *sqlite.Error
		if errors.As(err, &sqliteErr) {
			return nil, fault.New(
				sqlite.ErrorCodeString[sqliteErr.Code()],
			)
		}

		return nil, fault.Wrap(err, fmsg.With("failed to open sqlite database"))
	}

	return db, nil
}

func (p *DB) Open(ctx context.Context) (err error) {
	p.db, err = p.openDB("rw")
	if err != nil {
		return fault.Wrap(err)
	}

	p.stmt, err = p.db.PrepareContext(ctx, `
SELECT name
FROM programs
WHERE package = ?
`)
	if err != nil {
		return fault.Wrap(err, fmsg.With("failed to prepare statement"))
	}
	p.logger.Debug("prepared statement")

	return nil
}

func (p *DB) Close() error {
	if err := p.db.Close(); err != nil {
		return fault.Wrap(err, fmsg.With("failed to close sqlite database"))
	}

	return nil
}

func (p *DB) GetPackagePrograms(ctx context.Context, pkg string) ([]string, error) {
	var programs []string
	rows, err := p.stmt.QueryContext(ctx, pkg)
	if err != nil {
		return nil, fault.Wrap(err, fmsg.With("failed to execute query"))
	}
	defer rows.Close()

	for rows.Next() {
		var name string
		if err := rows.Scan(&name); err != nil {
			return nil, fault.Wrap(err, fmsg.With("failed to scan row"))
		}

		programs = append(programs, name)
	}
	rerr := rows.Close()
	if rerr != nil {
		return nil, fault.Wrap(rerr, fmsg.With("sql error"))
	}

	return programs, nil
}