package store

import (
	"context"
	"database/sql"
	"errors"
	"time"

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

// ApprovalPolicy is de instelling voor verplichte goedkeuringen.
// Configured onderscheidt "nooit bewaard" van een bewuste keuze,
// ook als die keuze de eis uitzet. Een bewaarde groepsregel wint
// van de projectregel.
type ApprovalPolicy struct {
	Configured         bool
	MaintainerRequired bool
	RequiredCount      int
	DevelopersApprove  bool
}

// GetApproval leest de regel. Zonder rij is hij niet ingesteld en is het aantal 1.
func (s *Store) GetApproval(ctx context.Context, scopeKind string, scopeID int64) (ApprovalPolicy, error) {
	var configured, required, developers int
	var count int
	err := s.db.QueryRowContext(ctx, `SELECT configured, maintainer_required, required_count, developers_approve FROM approval_rules WHERE scope_kind = ? AND scope_id = ?`, scopeKind, scopeID).Scan(&configured, &required, &count, &developers)
	if errors.Is(err, sql.ErrNoRows) {
		return ApprovalPolicy{RequiredCount: 1}, nil
	}
	if err != nil {
		return ApprovalPolicy{}, err
	}
	if count < 1 {
		count = 1
	}
	return ApprovalPolicy{
		Configured: configured == 1, MaintainerRequired: required == 1,
		RequiredCount: count, DevelopersApprove: developers == 1,
	}, nil
}

// SaveApproval bewaart de regel en markeert hem als ingesteld.
func (s *Store) SaveApproval(ctx context.Context, scopeKind string, scopeID int64, p ApprovalPolicy) error {
	if p.RequiredCount < 1 {
		p.RequiredCount = 1
	}
	if p.RequiredCount > 100 {
		p.RequiredCount = 100
	}
	_, err := s.db.ExecContext(ctx, `INSERT INTO approval_rules (scope_kind, scope_id, configured, maintainer_required, required_count, developers_approve)
		VALUES (?, ?, 1, ?, ?, ?)
		ON CONFLICT(scope_kind, scope_id) DO UPDATE SET configured = 1, maintainer_required = excluded.maintainer_required, required_count = excluded.required_count, developers_approve = excluded.developers_approve`,
		scopeKind, scopeID, boolInt(p.MaintainerRequired), p.RequiredCount, boolInt(p.DevelopersApprove))
	return err
}

// EffectiveApproval is de regel die voor een repository geldt.
// Een ingestelde groepsregel vervangt de projectregel.
func (s *Store) EffectiveApproval(ctx context.Context, repo Repo) (ApprovalPolicy, string, error) {
	if repo.OwnerKind == "group" {
		p, err := s.GetApproval(ctx, "group", repo.OwnerID)
		if err != nil {
			return ApprovalPolicy{}, "", err
		}
		if p.Configured {
			g, err := s.GroupByID(ctx, repo.OwnerID)
			if err != nil {
				return ApprovalPolicy{}, "", err
			}
			return p, g.Path, nil
		}
	}
	p, err := s.GetApproval(ctx, "repo", repo.ID)
	return p, "", err
}

// GroupMaintainerCount telt beheerders, inclusief de maker van de groep.
func (s *Store) GroupMaintainerCount(ctx context.Context, groupID int64) (int, error) {
	g, err := s.GroupByID(ctx, groupID)
	if err != nil {
		return 0, err
	}
	ids := map[int64]bool{g.OwnerID: true}
	members, err := s.ListMembers(ctx, "group", groupID)
	if err != nil {
		return 0, err
	}
	for _, m := range members {
		if !m.Pending && m.Role == access.RoleMaintainer && m.UserID != 0 {
			ids[m.UserID] = true
		}
	}
	return len(ids), nil
}

// ProjectMaintainerCount telt wie op dit project beheerder is.
// Bij een groep horen de groepsbeheerders en de maker daar ook bij.
func (s *Store) ProjectMaintainerCount(ctx context.Context, repo Repo) (int, error) {
	ids := map[int64]bool{}
	if repo.OwnerKind == "user" {
		ids[repo.OwnerID] = true
	}
	if repo.OwnerKind == "group" {
		g, err := s.GroupByID(ctx, repo.OwnerID)
		if err != nil {
			return 0, err
		}
		ids[g.OwnerID] = true
		members, err := s.ListMembers(ctx, "group", g.ID)
		if err != nil {
			return 0, err
		}
		for _, m := range members {
			if !m.Pending && m.Role == access.RoleMaintainer && m.UserID != 0 {
				ids[m.UserID] = true
			}
		}
	}
	members, err := s.ListMembers(ctx, "repo", repo.ID)
	if err != nil {
		return 0, err
	}
	for _, m := range members {
		if !m.Pending && m.Role == access.RoleMaintainer && m.UserID != 0 {
			ids[m.UserID] = true
		}
	}
	return len(ids), nil
}

// Review is de huidige review van één persoon op een merge request.
type Review struct {
	UserID    int64
	Username  string
	Status    string
	UpdatedAt time.Time
}

// UpsertReview zet de review van deze gebruiker.
// status is approved, changes, rejected of dismissed.
func (s *Store) UpsertReview(ctx context.Context, repoID, mrID, userID int64, status string) error {
	_, err := s.db.ExecContext(ctx, `INSERT INTO reviews (repo_id, mr_id, user_id, status, updated_at) VALUES (?, ?, ?, ?, ?)
		ON CONFLICT(mr_id, user_id) DO UPDATE SET status = excluded.status, updated_at = excluded.updated_at`,
		repoID, mrID, userID, status, now())
	return err
}

// ListReviews geeft elke reviewer, oudste bijwerking eerst.
func (s *Store) ListReviews(ctx context.Context, mrID int64) ([]Review, error) {
	rows, err := s.db.QueryContext(ctx, `SELECT r.user_id, u.username, r.status, r.updated_at FROM reviews r JOIN users u ON u.id = r.user_id WHERE r.mr_id = ? ORDER BY r.updated_at, r.user_id`, mrID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []Review
	for rows.Next() {
		var rev Review
		var updated string
		if err := rows.Scan(&rev.UserID, &rev.Username, &rev.Status, &updated); err != nil {
			return nil, err
		}
		rev.UpdatedAt = parseTime(updated)
		out = append(out, rev)
	}
	return out, rows.Err()
}
