package repository

import (
	"context"
	"time"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgxpool"
	"github.com/ren/econ/backend/internal/models"
)

type ProgresoRepository struct {
	db *pgxpool.Pool
}

func NewProgresoRepository(db *pgxpool.Pool) *ProgresoRepository {
	return &ProgresoRepository{db: db}
}

func (r *ProgresoRepository) GetByUsuario(ctx context.Context, usuarioID uuid.UUID) ([]models.Progreso, error) {
	query := `
		SELECT id, usuario_id, modulo_numero, ejercicio_id, completado, puntuacion, intentos, ultima_vez, respuesta_json
		FROM progreso_usuario WHERE usuario_id = $1
		ORDER BY ultima_vez DESC
	`
	rows, err := r.db.Query(ctx, query, usuarioID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var progresos []models.Progreso
	for rows.Next() {
		var p models.Progreso
		err := rows.Scan(
			&p.ID, &p.UsuarioID, &p.ModuloNumero, &p.EjercicioID,
			&p.Completado, &p.Puntuacion, &p.Intentos, &p.UltimaVez, &p.RespuestaJSON)
		if err != nil {
			return nil, err
		}
		progresos = append(progresos, p)
	}
	return progresos, nil
}

func (r *ProgresoRepository) GetByModulo(ctx context.Context, usuarioID uuid.UUID, moduloNumero int) ([]models.Progreso, error) {
	query := `
		SELECT id, usuario_id, modulo_numero, ejercicio_id, completado, puntuacion, intentos, ultima_vez, respuesta_json
		FROM progreso_usuario WHERE usuario_id = $1 AND modulo_numero = $2
		ORDER BY ejercicio_id
	`
	rows, err := r.db.Query(ctx, query, usuarioID, moduloNumero)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var progresos []models.Progreso
	for rows.Next() {
		var p models.Progreso
		err := rows.Scan(
			&p.ID, &p.UsuarioID, &p.ModuloNumero, &p.EjercicioID,
			&p.Completado, &p.Puntuacion, &p.Intentos, &p.UltimaVez, &p.RespuestaJSON)
		if err != nil {
			return nil, err
		}
		progresos = append(progresos, p)
	}
	return progresos, nil
}

func (r *ProgresoRepository) GetByEjercicio(ctx context.Context, usuarioID uuid.UUID, ejercicioID int) (*models.Progreso, error) {
	query := `
		SELECT id, usuario_id, modulo_numero, ejercicio_id, completado, puntuacion, intentos, ultima_vez, respuesta_json
		FROM progreso_usuario WHERE usuario_id = $1 AND ejercicio_id = $2
	`
	var p models.Progreso
	err := r.db.QueryRow(ctx, query, usuarioID, ejercicioID).Scan(
		&p.ID, &p.UsuarioID, &p.ModuloNumero, &p.EjercicioID,
		&p.Completado, &p.Puntuacion, &p.Intentos, &p.UltimaVez, &p.RespuestaJSON)
	if err != nil {
		return nil, err
	}
	return &p, nil
}

func (r *ProgresoRepository) Upsert(ctx context.Context, usuarioID uuid.UUID, ejercicioID int, update *models.ProgresoUpdate) error {
	query := `
		INSERT INTO progreso_usuario (id, usuario_id, modulo_numero, ejercicio_id, completado, puntuacion, intentos, ultima_vez, respuesta_json)
		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
		ON CONFLICT (usuario_id, modulo_numero, ejercicio_id)
		DO UPDATE SET completado = $5, puntuacion = $6, intentos = $7, ultima_vez = $8, respuesta_json = $9
	`

	moduloNumero, err := r.getModuloByEjercicio(ctx, ejercicioID)
	if err != nil {
		return err
	}

	existing, _ := r.GetByEjercicio(ctx, usuarioID, ejercicioID)
	var intentos int
	if existing != nil {
		intentos = existing.Intentos + 1
	} else {
		intentos = 1
	}

	_, err = r.db.Exec(ctx, query,
		uuid.New(), usuarioID, moduloNumero, ejercicioID,
		update.Completado, update.Puntuacion, intentos, time.Now(), update.RespuestaJSON)
	return err
}

func (r *ProgresoRepository) getModuloByEjercicio(ctx context.Context, ejercicioID int) (int, error) {
	var moduloNumero int
	err := r.db.QueryRow(ctx, "SELECT modulo_numero FROM ejercicios WHERE id = $1", ejercicioID).Scan(&moduloNumero)
	return moduloNumero, err
}

func (r *ProgresoRepository) GetResumen(ctx context.Context, usuarioID uuid.UUID) (*models.ProgresoResumen, error) {
	query := `
		SELECT
			COUNT(DISTINCT ejercicio_id) as total,
			COUNT(CASE WHEN completado THEN 1 END) as completados,
			COALESCE(AVG(CASE WHEN completado THEN puntuacion END), 0)::int as promedio,
			COUNT(DISTINCT CASE WHEN completado THEN modulo_numero END) as modulos
		FROM progreso_usuario WHERE usuario_id = $1
	`
	var resumen models.ProgresoResumen
	err := r.db.QueryRow(ctx, query, usuarioID).Scan(
		&resumen.TotalEjercicios, &resumen.EjerciciosCompletados,
		&resumen.PromedioPuntuacion, &resumen.ModulosCompletados)
	if err != nil {
		return nil, err
	}
	return &resumen, nil
}

func (r *ProgresoRepository) GetByUsuarioID(ctx context.Context, usuarioID uuid.UUID) ([]models.Progreso, error) {
	return r.GetByUsuario(ctx, usuarioID)
}