website/storage/syndicate.go

package storage

import (
	"database/sql"
	"synlotto-website/models"
)

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 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 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 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 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
}

func GetUserByUsername(db *sql.DB, username string) *models.User {
	row := db.QueryRow(`SELECT id, username, is_admin FROM users WHERE username = ?`, username)
	var u models.User
	err := row.Scan(&u.Id, &u.Username, &u.IsAdmin)
	if err != nil {
		return nil
	}
	return &u
}

func AddMemberToSyndicate(db *sql.DB, syndicateID, userID int) error {
	_, err := db.Exec(`
		INSERT INTO syndicate_members (syndicate_id, user_id, joined_at)
		VALUES (?, ?, CURRENT_TIMESTAMP)
	`, syndicateID, userID)
	return err
}

func GetSyndicateTickets(db *sql.DB, syndicateID int) []models.Ticket {
	rows, err := db.Query(`
		SELECT id, userId, syndicateId, game_type, draw_date, ball1, ball2, ball3, ball4, ball5, ball6,
		       bonus1, bonus2, matched_main, matched_bonus, prize_tier, prize_amount, prize_label, is_winner
		FROM my_tickets
		WHERE syndicateId = ?
		ORDER BY draw_date DESC
	`, syndicateID)
	if err != nil {
		return nil
	}
	defer rows.Close()

	var tickets []models.Ticket
	for rows.Next() {
		var t models.Ticket
		err := rows.Scan(
			&t.Id, &t.UserId, &t.SyndicateId, &t.GameType, &t.DrawDate,
			&t.Ball1, &t.Ball2, &t.Ball3, &t.Ball4, &t.Ball5, &t.Ball6,
			&t.Bonus1, &t.Bonus2, &t.MatchedMain, &t.MatchedBonus,
			&t.PrizeTier, &t.PrizeAmount, &t.PrizeLabel, &t.IsWinner,
		)
		if err == nil {
			tickets = append(tickets, t)
		}
	}
	return tickets
}

func InviteUserToSyndicate(db *sql.DB, syndicateID, invitedUserID, senderID int) error {
	_, err := db.Exec(`
		INSERT INTO syndicate_invites (syndicate_id, invited_user_id, sent_by_user_id)
		VALUES (?, ?, ?)
	`, syndicateID, invitedUserID, senderID)
	return err
}

func GetPendingInvites(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 UpdateInviteStatus(db *sql.DB, inviteID int, status string) error {
	_, err := db.Exec(`
		UPDATE syndicate_invites
		SET status = ?
		WHERE id = ?
	`, status, inviteID)
	return err
}

func AcceptInvite(db *sql.DB, inviteID, userID int) error {
	var syndicateID int
	err := db.QueryRow(`
		SELECT syndicate_id FROM syndicate_invites
		WHERE id = ? AND invited_user_id = ? AND status = 'pending'
	`, inviteID, userID).Scan(&syndicateID)
	if err != nil {
		return err
	}

	if err := UpdateInviteStatus(db, inviteID, "accepted"); err != nil {
		return err
	}

	_, err = db.Exec(`
		INSERT INTO syndicate_members (syndicate_id, user_id, joined_at)
		VALUES (?, ?, CURRENT_TIMESTAMP)
	`, syndicateID, userID)
	return err
}