package storage

import (
	"database/sql"

	"synlotto-website/internal/models"
)

func GetInviteTokensForSyndicate(db *sql.DB, syndicateID int) []models.SyndicateInviteToken {
	rows, err := db.Query(`
		SELECT token, invited_by_user_id, accepted_by_user_id, created_at, expires_at, accepted_at
		FROM syndicate_invite_tokens
		WHERE syndicate_id = ?
		ORDER BY created_at DESC
	`, syndicateID)
	if err != nil {
		return nil
	}
	defer rows.Close()

	var tokens []models.SyndicateInviteToken
	for rows.Next() {
		var t models.SyndicateInviteToken
		_ = rows.Scan(
			&t.Token,
			&t.InvitedByUserID,
			&t.AcceptedByUserID,
			&t.CreatedAt,
			&t.ExpiresAt,
			&t.AcceptedAt,
		)
		tokens = append(tokens, t)
	}
	return tokens
}

func GetPendingSyndicateInvites(db *sql.DB, userID int) []models.SyndicateInvite {
	rows, err := db.Query(`
		SELECT id, syndicate_id, invited_user_id, sent_by_user_id, status, created_at
		FROM syndicate_invites
		WHERE invited_user_id = ? AND status = 'pending'
	`, userID)
	if err != nil {
		return nil
	}
	defer rows.Close()

	var invites []models.SyndicateInvite
	for rows.Next() {
		var i models.SyndicateInvite
		rows.Scan(&i.ID, &i.SyndicateID, &i.InvitedUserID, &i.SentByUserID, &i.Status, &i.CreatedAt)
		invites = append(invites, i)
	}
	return invites
}

func GetSyndicateByID(db *sql.DB, id int) (*models.Syndicate, error) {
	row := db.QueryRow(`SELECT id, name, description, owner_id, created_at FROM syndicates WHERE id = ?`, id)
	var s models.Syndicate
	err := row.Scan(&s.ID, &s.Name, &s.Description, &s.OwnerID, &s.CreatedAt)
	if err != nil {
		return nil, err
	}
	return &s, nil
}

func GetSyndicatesByMember(db *sql.DB, userID int) []models.Syndicate {
	rows, err := db.Query(`
		SELECT s.id, s.name, s.description, s.created_at, s.owner_id
		FROM syndicates s
		JOIN syndicate_members m ON s.id = m.syndicate_id
		WHERE m.user_id = ?`, userID)
	if err != nil {
		return nil
	}
	defer rows.Close()

	var syndicates []models.Syndicate
	for rows.Next() {
		var s models.Syndicate
		err := rows.Scan(&s.ID, &s.Name, &s.Description, &s.CreatedAt, &s.OwnerID)
		if err == nil {
			syndicates = append(syndicates, s)
		}
	}
	return syndicates
}

func GetSyndicatesByOwner(db *sql.DB, ownerID int) []models.Syndicate {
	rows, err := db.Query(`
		SELECT id, name, description, created_at, owner_id 
		FROM syndicates 
		WHERE owner_id = ?`, ownerID)
	if err != nil {
		return nil
	}
	defer rows.Close()

	var syndicates []models.Syndicate
	for rows.Next() {
		var s models.Syndicate
		err := rows.Scan(&s.ID, &s.Name, &s.Description, &s.CreatedAt, &s.OwnerID)
		if err == nil {
			syndicates = append(syndicates, s)
		}
	}
	return syndicates
}

func GetSyndicateMembers(db *sql.DB, syndicateID int) []models.SyndicateMember {
	rows, err := db.Query(`
		SELECT m.user_id, u.username, m.joined_at
		FROM syndicate_members m
		JOIN users u ON u.id = m.user_id
		WHERE m.syndicate_id = ?
	`, syndicateID)
	if err != nil {
		return nil
	}
	defer rows.Close()

	var members []models.SyndicateMember
	for rows.Next() {
		var m models.SyndicateMember
		err := rows.Scan(&m.UserID, &m.UserID, &m.JoinedAt)
		if err == nil {
			members = append(members, m)
		}
	}
	return members
}

func IsSyndicateManager(db *sql.DB, syndicateID, userID int) bool {
	var count int
	err := db.QueryRow(`
		SELECT COUNT(*) FROM syndicates 
		WHERE id = ? AND owner_id = ?
	`, syndicateID, userID).Scan(&count)
	return err == nil && count > 0
}

func IsSyndicateMember(db *sql.DB, syndicateID, userID int) bool {
	var count int
	err := db.QueryRow(`SELECT COUNT(*) FROM syndicate_members WHERE syndicate_id = ? AND user_id = ?`, syndicateID, userID).Scan(&count)
	return err == nil && count > 0
}