package database

import (
	"context"
	"database/sql"
	"fmt"
)

type ChunkFileRepository struct {
	db *DB
}

func NewChunkFileRepository(db *DB) *ChunkFileRepository {
	return &ChunkFileRepository{db: db}
}

func (r *ChunkFileRepository) Create(ctx context.Context, tx *sql.Tx, cf *ChunkFile) error {
	query := `
		INSERT INTO chunk_files (chunk_hash, file_id, file_offset, length)
		VALUES (?, ?, ?, ?)
		ON CONFLICT(chunk_hash, file_id) DO NOTHING
	`

	var err error
	if tx != nil {
		_, err = tx.ExecContext(ctx, query, cf.ChunkHash, cf.FileID, cf.FileOffset, cf.Length)
	} else {
		_, err = r.db.ExecWithLog(ctx, query, cf.ChunkHash, cf.FileID, cf.FileOffset, cf.Length)
	}

	if err != nil {
		return fmt.Errorf("inserting chunk_file: %w", err)
	}

	return nil
}

func (r *ChunkFileRepository) GetByChunkHash(ctx context.Context, chunkHash string) ([]*ChunkFile, error) {
	query := `
		SELECT chunk_hash, file_id, file_offset, length
		FROM chunk_files
		WHERE chunk_hash = ?
	`

	rows, err := r.db.conn.QueryContext(ctx, query, chunkHash)
	if err != nil {
		return nil, fmt.Errorf("querying chunk files: %w", err)
	}
	defer CloseRows(rows)

	var chunkFiles []*ChunkFile
	for rows.Next() {
		var cf ChunkFile
		err := rows.Scan(&cf.ChunkHash, &cf.FileID, &cf.FileOffset, &cf.Length)
		if err != nil {
			return nil, fmt.Errorf("scanning chunk file: %w", err)
		}
		chunkFiles = append(chunkFiles, &cf)
	}

	return chunkFiles, rows.Err()
}

func (r *ChunkFileRepository) GetByFilePath(ctx context.Context, filePath string) ([]*ChunkFile, error) {
	query := `
		SELECT cf.chunk_hash, cf.file_id, cf.file_offset, cf.length
		FROM chunk_files cf
		JOIN files f ON cf.file_id = f.id
		WHERE f.path = ?
	`

	rows, err := r.db.conn.QueryContext(ctx, query, filePath)
	if err != nil {
		return nil, fmt.Errorf("querying chunk files: %w", err)
	}
	defer CloseRows(rows)

	var chunkFiles []*ChunkFile
	for rows.Next() {
		var cf ChunkFile
		err := rows.Scan(&cf.ChunkHash, &cf.FileID, &cf.FileOffset, &cf.Length)
		if err != nil {
			return nil, fmt.Errorf("scanning chunk file: %w", err)
		}
		chunkFiles = append(chunkFiles, &cf)
	}

	return chunkFiles, rows.Err()
}

// GetByFileID retrieves chunk files by file ID
func (r *ChunkFileRepository) GetByFileID(ctx context.Context, fileID string) ([]*ChunkFile, error) {
	query := `
		SELECT chunk_hash, file_id, file_offset, length
		FROM chunk_files
		WHERE file_id = ?
	`

	rows, err := r.db.conn.QueryContext(ctx, query, fileID)
	if err != nil {
		return nil, fmt.Errorf("querying chunk files: %w", err)
	}
	defer CloseRows(rows)

	var chunkFiles []*ChunkFile
	for rows.Next() {
		var cf ChunkFile
		err := rows.Scan(&cf.ChunkHash, &cf.FileID, &cf.FileOffset, &cf.Length)
		if err != nil {
			return nil, fmt.Errorf("scanning chunk file: %w", err)
		}
		chunkFiles = append(chunkFiles, &cf)
	}

	return chunkFiles, rows.Err()
}

// DeleteByFileID deletes all chunk_files entries for a given file ID
func (r *ChunkFileRepository) DeleteByFileID(ctx context.Context, tx *sql.Tx, fileID string) error {
	query := `DELETE FROM chunk_files WHERE file_id = ?`

	var err error
	if tx != nil {
		_, err = tx.ExecContext(ctx, query, fileID)
	} else {
		_, err = r.db.ExecWithLog(ctx, query, fileID)
	}

	if err != nil {
		return fmt.Errorf("deleting chunk files: %w", err)
	}

	return nil
}