package store

import (
	"context"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// SetLanguage bewaart de taalkeuze van een gebruiker.
func (s *Store) SetLanguage(ctx context.Context, userID int64, lang string) error {
	_, err := s.db.ExecContext(ctx, `UPDATE users SET language = ? WHERE id = ?`, string(i18n.Parse(lang)), userID)
	return err
}

// UpdateGroup wijzigt beschrijving, zichtbaarheid en de standaardrol.
func (s *Store) UpdateGroup(ctx context.Context, id int64, description, visibility string, defaultRole access.Role) error {
	if visibility != "public" && visibility != "private" {
		return i18n.E("err.visibility")
	}
	if _, err := access.ParseRole(string(defaultRole)); err != nil {
		return err
	}
	_, err := s.db.ExecContext(ctx, `UPDATE groups SET description = ?, visibility = ?, default_role = ? WHERE id = ?`,
		strings.TrimSpace(description), visibility, string(defaultRole), id)
	return err
}

// SetLogoMIME onthoudt het type van een opgeslagen logo. Leeg wist het.
func (s *Store) SetLogoMIME(ctx context.Context, kind string, id int64, mime string) error {
	switch kind {
	case "group":
		_, err := s.db.ExecContext(ctx, `UPDATE groups SET logo_mime = ? WHERE id = ?`, mime, id)
		return err
	case "repo":
		_, err := s.db.ExecContext(ctx, `UPDATE repos SET logo_mime = ? WHERE id = ?`, mime, id)
		return err
	default:
		return i18n.E("err.scope")
	}
}

// GrantDefaultRoles zet op een nieuwe groepsrepository de standaardrol
// voor elk huidig lid. Beheerders van de groep blijven beheerder.
func (s *Store) GrantDefaultRoles(ctx context.Context, groupID, repoID int64) error {
	g, err := s.GroupByID(ctx, groupID)
	if err != nil {
		return err
	}
	rows, err := s.db.QueryContext(ctx, `SELECT user_id, role FROM group_members WHERE group_id = ?`, groupID)
	if err != nil {
		return err
	}
	defer rows.Close()
	for rows.Next() {
		var uid int64
		var role string
		if err := rows.Scan(&uid, &role); err != nil {
			return err
		}
		grant := g.DefaultRole
		if access.Role(role) == access.RoleMaintainer {
			grant = access.RoleMaintainer
		}
		if _, err := s.db.ExecContext(ctx, `INSERT INTO repo_members (repo_id, user_id, role) VALUES (?, ?, ?)
			ON CONFLICT(repo_id, user_id) DO UPDATE SET role = excluded.role`, repoID, uid, string(grant)); err != nil {
			return err
		}
	}
	return rows.Err()
}

// SlugTaken meldt of een groeps- of repositorynaam al bezet is.
func (s *Store) SlugTaken(ctx context.Context, kind, slug, ownerKind string, ownerID int64) (bool, error) {
	var n int
	var err error
	switch kind {
	case "group":
		err = s.db.QueryRowContext(ctx, `SELECT
			(SELECT COUNT(*) FROM users WHERE username = ?) +
			(SELECT COUNT(*) FROM groups WHERE path = ?)`, slug, slug).Scan(&n)
	case "repo":
		err = s.db.QueryRowContext(ctx, `SELECT COUNT(*) FROM repos WHERE owner_kind = ? AND owner_id = ? AND name = ?`, ownerKind, ownerID, slug).Scan(&n)
	default:
		return true, nil
	}
	if err != nil {
		return false, err
	}
	return n > 0, nil
}

// SetStar zet of haalt een ster weg.
func (s *Store) SetStar(ctx context.Context, userID, repoID int64, on bool) error {
	if !on {
		_, err := s.db.ExecContext(ctx, `DELETE FROM stars WHERE user_id = ? AND repo_id = ?`, userID, repoID)
		return err
	}
	_, err := s.db.ExecContext(ctx, `INSERT INTO stars (user_id, repo_id, created_at) VALUES (?, ?, ?)
		ON CONFLICT(user_id, repo_id) DO NOTHING`, userID, repoID, now())
	return err
}

// StarInfo telt sterren en meldt welke de gebruiker zelf zette.
func (s *Store) StarInfo(ctx context.Context, userID int64, ids []int64) (map[int64]int, map[int64]bool, error) {
	counts := map[int64]int{}
	mine := map[int64]bool{}
	if len(ids) == 0 {
		return counts, mine, nil
	}
	q, args := inClause(ids)
	rows, err := s.db.QueryContext(ctx, `SELECT repo_id, COUNT(*) FROM stars WHERE repo_id IN (`+q+`) GROUP BY repo_id`, args...)
	if err != nil {
		return nil, nil, err
	}
	defer rows.Close()
	for rows.Next() {
		var id int64
		var n int
		if err := rows.Scan(&id, &n); err != nil {
			return nil, nil, err
		}
		counts[id] = n
	}
	if err := rows.Err(); err != nil {
		return nil, nil, err
	}
	if userID == 0 {
		return counts, mine, nil
	}
	args = append([]any{userID}, args...)
	mrows, err := s.db.QueryContext(ctx, `SELECT repo_id FROM stars WHERE user_id = ? AND repo_id IN (`+q+`)`, args...)
	if err != nil {
		return nil, nil, err
	}
	defer mrows.Close()
	for mrows.Next() {
		var id int64
		if err := mrows.Scan(&id); err != nil {
			return nil, nil, err
		}
		mine[id] = true
	}
	return counts, mine, mrows.Err()
}

func inClause(ids []int64) (string, []any) {
	hold := make([]string, len(ids))
	args := make([]any, len(ids))
	for i, id := range ids {
		hold[i] = "?"
		args[i] = id
	}
	return strings.Join(hold, ","), args
}
