package db

import (
	"database/sql"
	"fmt"
	"strconv"
)

type Group struct {
	Id        string
	Name      string
	Reference string
	Members   []User
}

func (g *Group) MemberIndex(userId string) int {
	for i, u := range g.Members {
		if u.Id == userId {
			return i
		}
	}
	return -1
}

func queryForGroup(query string, args ...any) (*Group, error) {
	var group Group
	err := database.QueryRow(query, args...).Scan(&group.Id, &group.Name, &group.Reference)
	if err == sql.ErrNoRows {
		return nil, nil
	} else if err != nil {
		return nil, err
	}
	members, err := queryForGroupMembers(group.Id)
	if err != nil {
		return nil, err
	}
	group.Members = members
	return &group, nil
}

func queryForGroups(query string, args ...any) ([]Group, error) {
	groups := []Group{}
	rows, err := database.Query(query)
	if err != nil {
		return groups, err
	}
	defer rows.Close()
	for rows.Next() {
		var group Group
		err := rows.Scan(&group.Id, &group.Name, &group.Reference)
		if err != nil {
			return groups, err
		}
		members, err := queryForGroupMembers(group.Id)
		if err != nil {
			return groups, err
		}
		group.Members = members
		groups = append(groups, group)
	}
	err = rows.Err()
	if err != nil {
		return groups, err
	}
	return groups, nil
}

func queryForGroupMembers(groupId string) ([]User, error) {
	query := "SELECT user.id, user.name, user.reference, user.is_admin FROM user JOIN group_member ON group_member.user_id = user.id JOIN [group] ON [group].id = group_member.group_id WHERE [group].id = ? ORDER BY group_member.user_id"
	members, err := queryForUsers(query, groupId)
	if err != nil {
		return members, fmt.Errorf("Failed to get members: %w", err)
	}
	return members, nil
}

func GetGroupByReference(reference string) (*Group, error) {
	query := "SELECT [group].id, [group].name, [group].reference FROM [group] WHERE [group].reference = ?"
	return queryForGroup(query, reference)
}

func GetAllGroups() ([]Group, error) {
	query := "SELECT id, name, reference FROM [group];"
	return queryForGroups(query)
}

func CreateGroup(name string, reference string) (*Group, error) {
	stmt := "INSERT INTO [group] (name, reference) VALUES (?, ?)"
	result, err := database.Exec(stmt, name, reference)
	if err != nil {
		return nil, err
	}
	id, err := result.LastInsertId()
	if err != nil {
		return nil, err
	}
	group := Group{
		Id:        strconv.FormatInt(id, 10),
		Name:      name,
		Reference: reference,
	}
	return &group, nil
}

func (g *Group) AddUser(userId string) error {
	stmt := "INSERT INTO group_member (group_id, user_id) VALUES (?, ?)"
	_, err := database.Exec(stmt, g.Id, userId)
	if err != nil {
		return err
	}
	return nil
}

func (g *Group) RemoveUser(userId string) error {
	stmt := "DELETE FROM group_member WHERE group_id = ? AND user_id = ?"
	_, err := database.Exec(stmt, g.Id, userId)
	if err != nil {
		return err
	}
	return nil
}