package api

import (
	"errors"
	"fmt"

	"git.dubyatp.xyz/chat-api-server/db"
	"github.com/gocql/gocql"
)

func dbGetUser(id string) (*User, error) {
	query := `SELECT id, name, password FROM users WHERE id = ?`
	var user User
	err := db.Session.Query(query, id).Scan(&user.ID, &user.Name, &user.Password)
	if err == gocql.ErrNotFound {
		return nil, errors.New("User not found")
	} else if err != nil {
		return nil, fmt.Errorf("failed to query user: %v", err)
	}
	return &user, nil
}

func dbGetUserByName(username string) (*User, error) {

	query := `SELECT id, name, password FROM users WHERE name = ? ALLOW FILTERING`
	var user User
	err := db.Session.Query(query, username).Scan(&user.ID, &user.Name, &user.Password)
	if err == gocql.ErrNotFound {
		return nil, errors.New("User not found")
	} else if err != nil {
		return nil, fmt.Errorf("failed to query user: %v", err)
	}

	return &user, nil
}

func dbGetAllUsers() ([]*User, error) {
	query := `SELECT id, name, password FROM users`
	iter := db.Session.Query(query).Iter()
	defer iter.Close()

	var users []*User
	for {
		user := &User{}
		if !iter.Scan(&user.ID, &user.Name, &user.Password) {
			break
		}
		users = append(users, user)
	}

	if err := iter.Close(); err != nil {
		return nil, fmt.Errorf("failed to iterate users: %v", err)
	}

	if len(users) == 0 {
		return nil, errors.New("no users found")
	}

	return users, nil
}

func dbGetMessage(id string) (*Message, error) {
	query := `SELECT id, body, edited, timestamp, userid FROM messages WHERE id = ?`
	var message Message
	err := db.Session.Query(query, id).Scan(
		&message.ID,
		&message.Body,
		&message.Edited,
		&message.Timestamp,
		&message.UserID)
	if err == gocql.ErrNotFound {
		return nil, errors.New("Message not found")
	} else if err != nil {
		return nil, fmt.Errorf("failed to query message: %v", err)
	}

	return &message, nil
}

func dbGetAllMessages() ([]*Message, error) {
	query := `SELECT id, body, edited, timestamp, userid FROM messages`
	iter := db.Session.Query(query).Iter()
	defer iter.Close()

	var messages []*Message
	for {
		message := &Message{}
		if !iter.Scan(
			&message.ID,
			&message.Body,
			&message.Edited,
			&message.Timestamp,
			&message.UserID) {
			break
		}
		messages = append(messages, message)
	}

	if err := iter.Close(); err != nil {
		return nil, fmt.Errorf("failed to iterate messages: %v", err)
	}

	if len(messages) == 0 {
		return nil, errors.New("no messages found")
	}

	return messages, nil
}

func dbAddUser(user *User) error {
	query := `INSERT INTO users (id, name, password) VALUES (?, ?, ?)`
	err := db.Session.Query(query, user.ID, user.Name, user.Password).Exec()
	if err != nil {
		return fmt.Errorf("failed to add user: %v", err)
	}
	return nil
}

func dbAddMessage(message *Message) error {
	query := `INSERT INTO messages (id, body, edited, timestamp, userid)
			  VALUES (?, ?, ?, ?, ?)`
	err := db.Session.Query(query,
		message.ID,
		message.Body,
		nil,
		message.Timestamp,
		message.UserID).Exec()
	if err != nil {
		return fmt.Errorf("failed to add message: %v", err)
	}
	return nil
}

func dbUpdateMessage(updatedMessage *Message) error {
	var edited interface{}
	if updatedMessage.Edited.IsZero() {
		edited = nil
	} else {
		edited = updatedMessage.Edited
	}

	query := `UPDATE messages
			  SET body = ?, edited = ?, timestamp = ?
			  WHERE ID = ?`

	err := db.Session.Query(query,
		updatedMessage.Body,
		edited,
		updatedMessage.Timestamp,
		updatedMessage.ID).Exec()

	if err != nil {
		return fmt.Errorf("failed to update message: %v", err)
	}

	return nil

}

func dbDeleteMessage(id string) error {
	query := `DELETE FROM messages WHERE ID = ?`

	err := db.Session.Query(query, id).Exec()

	if err != nil {
		return fmt.Errorf("failed to delete message: %v", err)
	}

	return nil
}