package packs

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"strings"

	"github.com/nexuscrm/backend/internal/controlplane/layoutownership"
	"github.com/nexuscrm/shared/pkg/models"
)

const (
	legacyLayoutOwnershipResolveSpec = "data-specs/2026-04-27a-resolve-curated-layout-cutover-ownership.md"
	legacyLayoutOwnershipAuditSpec   = "data-specs/2026-04-27b-audit-curated-layout-cutover-ownership.md"
)

func shouldPreserveWildcardTarget(target *layoutownership.WildcardLayoutTarget) bool {
	return target != nil &&
		target.TargetPresent &&
		layoutownership.IsAdminOwnedLayoutAssignment(target.RouteSource)
}

func applyCuratedPageLayout(
	ctx context.Context,
	db *sql.DB,
	layout models.PageLayout,
	assignmentID string,
	logName string,
) error {
	if layout.ID == "" || layout.ObjectAPIName == "" {
		return fmt.Errorf("curated %s layout missing canonical identity", logName)
	}

	liveLayoutsBeforeApply, err := layoutownership.CountLivePageLayoutsForObject(ctx, db, layout.ObjectAPIName)
	if err != nil {
		return fmt.Errorf("count live %s layouts: %w", logName, err)
	}

	wildcardAssignmentCount, err := layoutownership.CountWildcardLayoutAssignments(ctx, db, layout.ObjectAPIName)
	if err != nil {
		return fmt.Errorf("count %s wildcard assignments: %w", logName, err)
	}

	wildcardTarget, err := layoutownership.LoadWildcardLayoutTarget(ctx, db, layout.ObjectAPIName)
	if err != nil {
		return fmt.Errorf("query %s wildcard assignment: %w", logName, err)
	}
	seedManagedWildcard := liveLayoutsBeforeApply == 0 && wildcardAssignmentCount == 0

	currentRow, err := layoutownership.LoadPageLayoutRow(ctx, db, layout.ID)
	if err != nil {
		return fmt.Errorf("query curated %s layout: %w", logName, err)
	}
	preserveCuratedRow := currentRow != nil &&
		layoutownership.IsAdminOwnedPageLayout(currentRow.IsCustomized, currentRow.Source)

	switch {
	case seedManagedWildcard:
		layout.IsDefault = true
	case wildcardTarget != nil:
		layout.IsDefault = wildcardTarget.LayoutID == layout.ID
	case currentRow != nil:
		layout.IsDefault = currentRow.IsDefault
	default:
		layout.IsDefault = false
	}

	if !preserveCuratedRow {
		if err := layoutownership.UpsertManagedPageLayout(ctx, db, layout, curatedLayoutSource); err != nil {
			return fmt.Errorf("upsert curated %s layout: %w", logName, err)
		}
	} else {
		log.Printf("   ⚠️  curated %s layout is admin-owned; preserving row %s", logName, layout.ID)
	}

	if !seedManagedWildcard {
		if wildcardTarget != nil && wildcardTarget.LayoutID != layout.ID {
			if err := layoutownership.ClearPageLayoutDefaultFlagByID(ctx, db, layout.ID); err != nil {
				return fmt.Errorf("clear curated %s default flag: %w", logName, err)
			}
		}
		if wildcardTarget != nil {
			log.Printf("   ⚠️  %s wildcard assignment preserved; default remains existing layout %s", logName, wildcardTarget.LayoutID)
		} else if wildcardAssignmentCount > 0 {
			log.Printf("   ⚠️  %s wildcard assignment is unresolved or orphaned; leaving default routing for operator data-spec resolution", logName)
		} else {
			log.Printf("   ⚠️  %s existing layouts found without wildcard routing; leaving legacy default choice for operator data-spec resolution", logName)
		}
		return nil
	}

	if err := layoutownership.ClearOtherPageLayoutDefaultFlags(ctx, db, layout.ObjectAPIName, layout.ID); err != nil {
		return fmt.Errorf("clear %s default flags: %w", logName, err)
	}
	if err := layoutownership.SetPageLayoutDefaultFlagByID(ctx, db, layout.ID); err != nil {
		return fmt.Errorf("set curated %s default flag: %w", logName, err)
	}

	if err := layoutownership.InsertWildcardLayoutAssignment(
		ctx,
		db,
		assignmentID,
		layout.ObjectAPIName,
		layout.ID,
		models.LayoutAssignmentRouteSourceManagedSeed,
	); err != nil {
		return fmt.Errorf("replace %s wildcard assignment: %w", logName, err)
	}
	return nil
}

func verifyCuratedPageLayout(db *sql.DB, objectAPIName, curatedLayoutID, logName string) error {
	var present int
	if err := db.QueryRow(`
		SELECT COUNT(*) FROM _System_PageLayout
		WHERE Id = ? AND ObjectApiName = ? AND (IsDeleted = 0 OR IsDeleted IS NULL)`,
		curatedLayoutID, objectAPIName,
	).Scan(&present); err != nil {
		return fmt.Errorf("query curated %s layout: %w", logName, err)
	}
	if present == 0 {
		return fmt.Errorf("curated %s layout missing (id=%s); run 'go run ./cmd/setup apply'", logName, curatedLayoutID)
	}

	target, err := layoutownership.LoadWildcardLayoutTarget(context.Background(), db, objectAPIName)
	if err != nil {
		return fmt.Errorf("query %s wildcard assignment: %w", logName, err)
	}
	if target == nil || target.LayoutID == "" {
		return nil
	}
	if target.LayoutID == curatedLayoutID {
		if target.RouteSource != nil &&
			(strings.EqualFold(strings.TrimSpace(*target.RouteSource), models.LayoutAssignmentRouteSourceManagedSeed) ||
				layoutownership.IsAdminOwnedLayoutAssignment(target.RouteSource)) {
			return nil
		}
		log.Printf("   ⚠️  %s wildcard assignment points to curated layout but has unresolved RouteSource; classify it via %s and verify via %s", logName, legacyLayoutOwnershipResolveSpec, legacyLayoutOwnershipAuditSpec)
		return nil
	}
	if shouldPreserveWildcardTarget(target) {
		return nil
	}
	log.Printf("   ⚠️  %s wildcard assignment points to non-curated platform route %q; leaving legacy routing for operator data-spec resolution", logName, target.LayoutID)
	return nil
}