package user

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

type Repository struct {
	Db *sql.DB
}

func NewRepository(db *sql.DB) (*Repository, error) {
	return &Repository{Db: db}, nil
}

func (r *Repository) CreateUser(ctx context.Context, login, password string) (*User, error) {
	query := "INSERT INTO users(login, password) VALUES(?, ?) RETURNING id, displayname, superuser"

	user := &User{Login: login, Password: password}
	if err := r.Db.QueryRowContext(ctx, query, login, password).Scan(&user.Id, &user.DisplayName, &user.SuperUser); err != nil {
		return nil, fmt.Errorf("db insert failed: %w", err)
	}

	return user, nil
}

func (r *Repository) GetUsers(ctx context.Context, limit, offset int64) ([]User, error) {
	query := "SELECT id, login, password, displayname, superuser FROM users LIMIT ? OFFSET ?"
	rows, err := r.Db.QueryContext(ctx, query, limit, offset)
	if err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}
	defer rows.Close()

	var users []User
	for rows.Next() {
		var user User

		if err := rows.Scan(&user.Id, &user.Login, &user.Password, &user.DisplayName, &user.SuperUser); err != nil {
			return nil, fmt.Errorf("db select failed: %w", err)
		}

		users = append(users, user)
	}

	if err := rows.Err(); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return users, nil
}

func (r *Repository) GetUserCount(ctx context.Context) (int64, error) {
	query := "SELECT COUNT(*) FROM users"
	var result int64
	if err := r.Db.QueryRowContext(ctx, query).Scan(&result); err != nil {
		return 0, fmt.Errorf("db select failed: %w", err)
	}

	return result, nil
}

func (r *Repository) GetUserById(ctx context.Context, id int64) (*User, error) {
	query := "SELECT login, password, displayname, superuser FROM users WHERE id = ?"
	user := &User{Id: id}
	if err := r.Db.QueryRowContext(ctx, query, id).Scan(&user.Login, &user.Password, &user.DisplayName, &user.SuperUser); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return user, nil
}

func (r *Repository) GetUserByLogin(ctx context.Context, login string) (*User, error) {
	query := "SELECT id, password, displayname, superuser FROM users WHERE login = ?"
	user := &User{Login: login}
	if err := r.Db.QueryRowContext(ctx, query, login).Scan(&user.Id, &user.Password, &user.DisplayName, &user.SuperUser); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return user, nil
}

func (r *Repository) UpdateUser(ctx context.Context, user *User) error {
	query := "UPDATE users SET password = ?, displayname = ?, superuser = ? WHERE id = ?"

	_, err := r.Db.ExecContext(ctx, query, user.Password, user.DisplayName, user.SuperUser, user.Id)
	if err != nil {
		return fmt.Errorf("db update failed: %w", err)
	}
	return nil
}

func (r *Repository) DeleteUser(ctx context.Context, id int64) error {
	query := "DELETE FROM users WHERE id = ?"

	_, err := r.Db.ExecContext(ctx, query, id)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}

func (r *Repository) CreateMetadata(ctx context.Context, id int64, data map[string]any) error {
	query := "INSERT INTO metadatas(id, data) VALUES(?, ?)"

	raw, err := json.Marshal(data)
	if err != nil {
		return fmt.Errorf("failed to marshal metadata: %w", err)
	}

	_, err = r.Db.ExecContext(ctx, query, id, raw)
	if err != nil {
		return fmt.Errorf("db insert failed: %w", err)
	}
	return nil
}

func (r *Repository) GetMetadata(ctx context.Context, id int64) (map[string]any, error) {
	query := "SELECT data FROM metadatas WHERE id = ?"

	var rawMetadata []byte
	if err := r.Db.QueryRowContext(ctx, query, id).Scan(&rawMetadata); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	var result map[string]any
	if err := json.Unmarshal(rawMetadata, &result); err != nil {
		return nil, fmt.Errorf("can't parse json: %w", err)
	}

	return result, nil
}

func (r *Repository) UpdateMetadata(ctx context.Context, id int64, data map[string]any) error {
	query := "UPDATE metadatas SET data = ? WHERE id = ?"

	raw, err := json.Marshal(data)
	if err != nil {
		return fmt.Errorf("failed to marshal metadata: %w", err)
	}

	_, err = r.Db.ExecContext(ctx, query, raw, id)
	if err != nil {
		return fmt.Errorf("db update failed: %w", err)
	}
	return nil
}

func (r *Repository) DeleteMetadata(ctx context.Context, id int64) error {
	query := "DELETE FROM metadatas WHERE id = ?"

	_, err := r.Db.ExecContext(ctx, query, id)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}

func (r *Repository) CreateAvatar(ctx context.Context, id int64, data []byte) error {
	query := "INSERT INTO avatars(id, data) VALUES(?, ?)"

	_, err := r.Db.ExecContext(ctx, query, id, data)
	if err != nil {
		return fmt.Errorf("db insert failed: %w", err)
	}
	return nil
}

func (r *Repository) GetAvatar(ctx context.Context, id int64) ([]byte, error) {
	query := "SELECT data FROM avatars WHERE id = ?"

	var result []byte
	if err := r.Db.QueryRowContext(ctx, query, id).Scan(&result); err != nil {
		return nil, fmt.Errorf("db select failed: %w", err)
	}

	return result, nil
}

func (r *Repository) UpdateAvatar(ctx context.Context, id int64, data []byte) error {
	query := "UPDATE avatars SET data = ? WHERE id = ?"

	_, err := r.Db.ExecContext(ctx, query, data, id)
	if err != nil {
		return fmt.Errorf("db update failed: %w", err)
	}
	return nil
}

func (r *Repository) DeleteAvatar(ctx context.Context, id int64) error {
	query := "DELETE FROM avatars WHERE id = ?"

	_, err := r.Db.ExecContext(ctx, query, id)
	if err != nil {
		return fmt.Errorf("db delete failed: %w", err)
	}
	return nil
}