package api

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"time"

	"git.dubyatp.xyz/dubyatp/scannerbot/server/db"
	"github.com/jackc/pgx/v5"
)

var ErrUserNotFound = errors.New("db: user not found")
var ErrSessionNotFound = errors.New("db: session not found")
var ErrChannelNotFound = errors.New("db: channel not found")
var ErrFileNotFound = errors.New("db: file not found")
var ErrMessageNotFound = errors.New("db: message not found")

func dbGetUser(id string) (*User, error) {
	query := `SELECT id, name, password FROM users WHERE id = $1`
	var user User
	err := db.Pool.QueryRow(context.Background(), query, id).Scan(&user.ID, &user.Name, &user.Password)
	if errors.Is(err, pgx.ErrNoRows) {
		slog.Debug("db: user not found", "userid", id)
		return nil, ErrUserNotFound
	} else if err != nil {
		slog.Error("db: failed to query user", "error", err)
		return nil, fmt.Errorf("failed to query user")
	}

	slog.Debug("db: user found", "userid", user.ID, "username", user.Name)
	return &user, nil
}

func dbGetUserByName(username string) (*User, error) {
	query := `SELECT id, name, password FROM users WHERE name = $1`
	var user User
	err := db.Pool.QueryRow(context.Background(), query, username).Scan(&user.ID, &user.Name, &user.Password)
	if errors.Is(err, pgx.ErrNoRows) {
		slog.Debug("db: user not found", "username", username)
		return nil, ErrUserNotFound
	} else if err != nil {
		slog.Error("db: failed to query user", "error", err)
		return nil, fmt.Errorf("failed to query user")
	}

	slog.Debug("db: user found", "userid", user.ID, "username", user.Name)
	return &user, nil
}

func dbGetAllUsers() ([]*User, error) {
	query := `SELECT id, name, password FROM users`
	rows, err := db.Pool.Query(context.Background(), query)
	if err != nil {
		slog.Error("db: failed to query users", "error", err)
		return nil, fmt.Errorf("failed to query users")
	}
	defer rows.Close()

	var users []*User
	for rows.Next() {
		user := &User{}
		if err := rows.Scan(&user.ID, &user.Name, &user.Password); err != nil {
			slog.Error("db: failed to scan user", "error", err)
			return nil, fmt.Errorf("failed to scan user")
		}
		users = append(users, user)
	}
	if err := rows.Err(); err != nil {
		slog.Error("db: row iteration error", "error", err)
		return nil, fmt.Errorf("failed to iterate users")
	}
	if len(users) == 0 {
		slog.Debug("db: no users found")
		return nil, ErrUserNotFound
	}

	slog.Debug("db: user list returned")
	return users, nil
}

func dbAddUser(user *User) error {
	query := `INSERT INTO users (id, name, password) VALUES ($1, $2, $3)`
	_, err := db.Pool.Exec(context.Background(), query, user.ID, user.Name, user.Password)
	if err != nil {
		slog.Error("db: failed to add user", "error", err, "userid", user.ID, "username", user.Name)
		return fmt.Errorf("failed to add user")
	}

	slog.Debug("db: user added", "userid", user.ID, "username", user.Name)
	return nil
}

func dbAddSession(session *Session) error {
	query := `INSERT INTO sessions (jwttoken, userid, expiry) VALUES ($1, $2, $3)`
	_, err := db.Pool.Exec(context.Background(), query, session.Token, session.UserID, session.Expiry)
	if err != nil {
		slog.Error("db: failed to add session", "error", err)
		return fmt.Errorf("failed to add session")
	}

	slog.Debug("db: session added", "userid", session.UserID)
	return nil
}

func dbGetSession(jwtToken string) (*Session, error) {
	query := `SELECT jwttoken, userid, expiry FROM sessions WHERE jwttoken = $1`

	var session Session
	err := db.Pool.QueryRow(context.Background(), query, jwtToken).Scan(&session.Token, &session.UserID, &session.Expiry)
	if errors.Is(err, pgx.ErrNoRows) {
		slog.Debug("db: session not found")
		return nil, ErrSessionNotFound
	} else if err != nil {
		slog.Error("db: failed to query session", "error", err)
		return nil, fmt.Errorf("failed to query session")
	}

	slog.Debug("db: session found", "userid", session.UserID)
	return &session, nil
}

func dbDeleteSession(jwtToken string) error {
	query := `DELETE FROM sessions WHERE jwttoken = $1`
	tag, err := db.Pool.Exec(context.Background(), query, jwtToken)
	if err != nil {
		slog.Error("db: failed to delete session", "error", err)
		return fmt.Errorf("failed to delete session")
	}
	if tag.RowsAffected() == 0 {
		return ErrSessionNotFound
	}

	slog.Debug("db: session deleted")
	return nil
}

func dbAddChannel(channel *Channel) error {
	query := `INSERT INTO channels (id, name, created, type, location, notes) VALUES ($1, $2, $3, $4, $5, $6)`
	_, err := db.Pool.Exec(context.Background(), query, channel.ID, channel.Name, channel.Created, channel.Type, channel.Location, channel.Notes)
	if err != nil {
		slog.Error("db: failed to add channel", "channel", err, "channelid", channel.ID, "channelname", channel.Name)
		return fmt.Errorf("failed to add channel")
	}

	slog.Debug("db: channel added", "channelid", channel.ID, "channelname", channel.Name)
	return nil
}

func dbGetChannel(id string) (*Channel, error) {
	query := `SELECT id, name, created, type, location, notes FROM channels WHERE id = $1`
	var channel Channel
	err := db.Pool.QueryRow(context.Background(), query, id).Scan(&channel.ID, &channel.Name, &channel.Created, &channel.Type, &channel.Location, &channel.Notes)
	if errors.Is(err, pgx.ErrNoRows) {
		slog.Debug("db: channel not found", "channelid", id)
		return nil, ErrChannelNotFound
	} else if err != nil {
		slog.Error("db: failed to query channel", "error", err)
		return nil, fmt.Errorf("failed to query channel")
	}

	slog.Debug("db: channel found", "channelid", channel.ID, "channelname", channel.Name)
	return &channel, nil
}

func dbGetAllChannels() ([]*Channel, error) {
	query := `SELECT id, name, created, type, location, notes FROM channels`
	rows, err := db.Pool.Query(context.Background(), query)
	if err != nil {
		slog.Error("db: failed to query channels", "error", err)
		return nil, fmt.Errorf("failed to query channels")
	}
	defer rows.Close()

	var channels []*Channel
	for rows.Next() {
		channel := &Channel{}
		if err := rows.Scan(&channel.ID, &channel.Name, &channel.Created, &channel.Type, &channel.Location, &channel.Notes); err != nil {
			slog.Error("db: failed to scan channel", "error", err)
			return nil, fmt.Errorf("failed to scan channel")
		}
		channels = append(channels, channel)
	}
	if err := rows.Err(); err != nil {
		slog.Error("db: row iteration error", "error", err)
		return nil, fmt.Errorf("failed to iterate channels")
	}
	if len(channels) == 0 {
		slog.Debug("db: no channels found")
		return nil, ErrChannelNotFound
	}

	slog.Debug("db: channel list returned")
	return channels, nil
}

func dbDeleteChannel(id string) error {
	query := `DELETE FROM channels WHERE id = $1`
	tag, err := db.Pool.Exec(context.Background(), query, id)
	if err != nil {
		slog.Error("db: failed to delete channel", "error", err)
		return fmt.Errorf("failed to delete channel")
	}
	if tag.RowsAffected() == 0 {
		return ErrChannelNotFound
	}

	slog.Debug("db: channel deleted")
	return nil
}

func dbAddFile(file *File) error {
	query := `INSERT INTO files (id, name, created, backend, path) VALUES ($1, $2, $3, $4, $5)`
	_, err := db.Pool.Exec(context.Background(), query, file.ID, file.Name, file.Created, file.Backend, file.Path)
	if err != nil {
		slog.Error("db: failed to add file", "error", err, "fileid", file.ID)
		return fmt.Errorf("failed to add file")
	}
	slog.Debug("db: file added", "fileid", file.ID, "filename", file.Name)
	return nil
}

func dbGetFile(id string) (*File, error) {
	query := `SELECT id, name, created, backend, path FROM files WHERE id = $1`
	var file File
	err := db.Pool.QueryRow(context.Background(), query, id).Scan(&file.ID, &file.Name, &file.Created, &file.Backend, &file.Path)
	if errors.Is(err, pgx.ErrNoRows) {
		slog.Debug("db: file not found", "fileid", id)
		return nil, ErrFileNotFound
	} else if err != nil {
		slog.Error("db: failed to query file", "error", err)
		return nil, fmt.Errorf("failed to query file")
	}
	slog.Debug("db: file found", "fileid", file.ID, "filename", file.Name)
	return &file, nil
}

func DBGetChannel(id string) (*Channel, error) { return dbGetChannel(id) }
func DBAddFile(file *File) error               { return dbAddFile(file) }

func DBAddMessage(msg *Message) error {
	query := `INSERT INTO messages (id, channel, created, content, audio) VALUES ($1, $2, $3, $4, $5)`
	_, err := db.Pool.Exec(context.Background(), query, msg.ID, msg.Channel.ID, msg.Created, msg.Content, msg.Audio.ID)
	if err != nil {
		slog.Error("db: failed to add message", "error", err, "messageid", msg.ID)
		return fmt.Errorf("failed to add message")
	}
	slog.Debug("db: message added", "messageid", msg.ID)
	return nil
}

func dbGetMessage(id string) (*Message, error) {
	query := `SELECT id, channel, created, content, audio FROM messages WHERE id = $1`
	var channelID, audioID string
	var msg Message
	err := db.Pool.QueryRow(context.Background(), query, id).Scan(&msg.ID, &channelID, &msg.Created, &msg.Content, &audioID)
	if errors.Is(err, pgx.ErrNoRows) {
		slog.Debug("db: message not found", "messageid", id)
		return nil, ErrMessageNotFound
	} else if err != nil {
		slog.Error("db: failed to query message", "error", err)
		return nil, fmt.Errorf("failed to query message")
	}

	channel, err := dbGetChannel(channelID)
	if err != nil {
		slog.Error("db: failed to fetch channel for message", "messageid", id, "channelid", channelID, "error", err)
		return nil, fmt.Errorf("failed to fetch channel for message")
	}
	audio, err := dbGetFile(audioID)
	if err != nil {
		slog.Error("db: failed to fetch audio for message", "messageid", id, "audioid", audioID, "error", err)
		return nil, fmt.Errorf("failed to fetch audio for message")
	}

	msg.Channel = *channel
	msg.Audio = *audio
	slog.Debug("db: message found", "messageid", msg.ID)
	return &msg, nil
}

func dbGetMessagesByChannel(channelID string, from, to *time.Time) ([]*Message, error) {
	query := `SELECT id, channel, created, content, audio FROM messages WHERE channel = $1`
	args := []any{channelID}
	if from != nil {
		args = append(args, *from)
		query += fmt.Sprintf(" AND created >= $%d", len(args))
	}
	if to != nil {
		args = append(args, *to)
		query += fmt.Sprintf(" AND created <= $%d", len(args))
	}
	query += " ORDER BY created DESC"
	rows, err := db.Pool.Query(context.Background(), query, args...)
	if err != nil {
		slog.Error("db: failed to query messages", "error", err)
		return nil, fmt.Errorf("failed to query messages")
	}
	defer rows.Close()

	type messageRow struct {
		msg       Message
		channelID string
		audioID   string
	}

	var rows_ []messageRow
	for rows.Next() {
		var mr messageRow
		if err := rows.Scan(&mr.msg.ID, &mr.channelID, &mr.msg.Created, &mr.msg.Content, &mr.audioID); err != nil {
			slog.Error("db: failed to scan message", "error", err)
			return nil, fmt.Errorf("failed to scan message")
		}
		rows_ = append(rows_, mr)
	}
	if err := rows.Err(); err != nil {
		slog.Error("db: row iteration error", "error", err)
		return nil, fmt.Errorf("failed to iterate messages")
	}
	if len(rows_) == 0 {
		slog.Debug("db: no messages found", "channelid", channelID)
		return nil, ErrMessageNotFound
	}

	channel, err := dbGetChannel(channelID)
	if err != nil {
		slog.Error("db: failed to fetch channel for messages", "channelid", channelID, "error", err)
		return nil, fmt.Errorf("failed to fetch channel for messages")
	}

	var messages []*Message
	for _, mr := range rows_ {
		audio, err := dbGetFile(mr.audioID)
		if err != nil {
			slog.Error("db: failed to fetch audio for message", "messageid", mr.msg.ID, "audioid", mr.audioID, "error", err)
			return nil, fmt.Errorf("failed to fetch audio for message")
		}
		mr.msg.Channel = *channel
		mr.msg.Audio = *audio
		messages = append(messages, &mr.msg)
	}

	slog.Debug("db: message list returned", "channelid", channelID, "count", len(messages))
	return messages, nil
}