package database

import (
	"context"
	"database/sql"
	"errors"

	"github.com/google/uuid"
)

func (s *service) CreateBrowserSession(ctx context.Context, session *BrowserSession) error {
	query := `
	INSERT INTO browser_sessions
	(id, display_number, vnc_port, debug_port, status, error_message, xvfb_pid, chrome_pid, vnc_pid)
	VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
			`
	_, err := s.db.ExecContext(ctx, query,
		session.ID,
		session.DisplayNumber,
		session.VNCPort,
		session.DebugPort,
		session.Status,
		session.ErrorMessage,
		session.XvfbPID,
		session.ChromePID,
		session.VNCPID,
	)
	return err
}

func (s *service) GetBrowserSession(ctx context.Context, id uuid.UUID) (*BrowserSession, error) {
	query := `
		SELECT id, display_number, vnc_port, debug_port, status, created_at, updated_at,
									error_message, xvfb_pid, chrome_pid, vnc_pid
		FROM browser_sessions
		WHERE id = $1
			`

	session := &BrowserSession{}
	err := s.db.QueryRowContext(ctx, query, id).Scan(
		&session.ID,
		&session.DisplayNumber,
		&session.VNCPort,
		&session.DebugPort,
		&session.Status,
		&session.CreatedAt,
		&session.UpdatedAt,
		&session.ErrorMessage,
		&session.XvfbPID,
		&session.ChromePID,
		&session.VNCPID,
	)

	if err == sql.ErrNoRows {
		return nil, errors.New("session not found")
	}
	return session, err
}

func (s *service) ListBrowserSessions(ctx context.Context) ([]*BrowserSession, error) {
	query := `
		SELECT id, display_number, vnc_port, debug_port, status, created_at, updated_at,
									error_message, xvfb_pid, chrome_pid, vnc_pid
		FROM browser_sessions
		WHERE status != $1
		ORDER BY created_at DESC
			`

	rows, err := s.db.QueryContext(ctx, query, StatusStopped)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var sessions []*BrowserSession
	for rows.Next() {
		session := &BrowserSession{}
		err := rows.Scan(
			&session.ID,
			&session.DisplayNumber,
			&session.VNCPort,
			&session.DebugPort,
			&session.Status,
			&session.CreatedAt,
			&session.UpdatedAt,
			&session.ErrorMessage,
			&session.XvfbPID,
			&session.ChromePID,
			&session.VNCPID,
		)
		if err != nil {
			return nil, err
		}
		sessions = append(sessions, session)
	}
	return sessions, nil
}

func (s *service) UpdateBrowserSession(ctx context.Context, session *BrowserSession) error {
	query := `
		UPDATE browser_sessions
		SET display_number = $1,
						vnc_port = $2,
						debug_port = $3,
						status = $4,
						error_message = $5,
						xvfb_pid = $6,
						chrome_pid = $7,
						vnc_pid = $8
		WHERE id = $9
			`

	result, err := s.db.ExecContext(ctx, query,
		session.DisplayNumber,
		session.VNCPort,
		session.DebugPort,
		session.Status,
		session.ErrorMessage,
		session.XvfbPID,
		session.ChromePID,
		session.VNCPID,
		session.ID,
	)
	if err != nil {
		return err
	}

	rows, err := result.RowsAffected()
	if err != nil {
		return err
	}
	if rows == 0 {
		return errors.New("session not found")
	}
	return nil
}

func (s *service) DeleteBrowserSession(ctx context.Context, id uuid.UUID) error {
	query := `DELETE FROM browser_sessions WHERE id = $1`
	result, err := s.db.ExecContext(ctx, query, id)
	if err != nil {
		return err
	}

	rows, err := result.RowsAffected()
	if err != nil {
		return err
	}
	if rows == 0 {
		return errors.New("session not found")
	}
	return nil
}

func (s *service) GetNextAvailableDisplayNumber(ctx context.Context) (int, error) {
	query := `
		WITH RECURSIVE numbers AS (
						SELECT 1 as num
						UNION ALL
						SELECT num + 1
						FROM numbers
						WHERE num < 100  -- Set a reasonable upper limit
		)
		SELECT num
		FROM numbers
		WHERE num NOT IN (
						SELECT display_number
						FROM browser_sessions
						WHERE status != $1
		)
		ORDER BY num
		LIMIT 1
			`

	var displayNumber int
	err := s.db.QueryRowContext(ctx, query, StatusStopped).Scan(&displayNumber)
	if err != nil {
		return 0, err
	}
	return displayNumber, nil
}