package postgres

import (
	"context"
	"encoding/json"
	"fmt"

	selfcontract "git.cin.su/m/Assistant/contracts/self"
	"github.com/jackc/pgx/v5/pgxpool"
)

// SelfRepository persists only SELF-owned derived assessments and ledger
// evidence. It never evaluates, promotes or changes Capability state.
type SelfRepository struct{ pool *pgxpool.Pool }

type AcceptanceSummary struct {
	LearningSignals    int    `json:"learning_signals"`
	ImprovementNeeds   int    `json:"improvement_needs"`
	LearningLedger     int    `json:"learning_ledger"`
	SyntheticPrincipal string `json:"synthetic_principal"`
}

func OpenSelf(ctx context.Context, config ContinuityConfig) (*SelfRepository, error) {
	pool, err := openPool(ctx, config)
	if err != nil {
		return nil, err
	}
	return &SelfRepository{pool: pool}, nil
}

func (r *SelfRepository) Close() { r.pool.Close() }

func (r *SelfRepository) AcceptanceSummary(ctx context.Context, principalID string) (AcceptanceSummary, error) {
	var value AcceptanceSummary
	value.SyntheticPrincipal = principalID
	if err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM self.learning_signals WHERE principal_id=$1`, principalID).Scan(&value.LearningSignals); err != nil {
		return AcceptanceSummary{}, err
	}
	if err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM self.improvement_needs WHERE principal_id=$1`, principalID).Scan(&value.ImprovementNeeds); err != nil {
		return AcceptanceSummary{}, err
	}
	if err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM self.learning_ledger WHERE principal_id=$1`, principalID).Scan(&value.LearningLedger); err != nil {
		return AcceptanceSummary{}, err
	}
	return value, nil
}

func (r *SelfRepository) SaveImprovementNeed(ctx context.Context, value selfcontract.ImprovementNeed) error {
	subject, err := json.Marshal(value.SubjectRef)
	if err != nil {
		return err
	}
	evidence, err := json.Marshal(value.EvidenceRefs)
	if err != nil {
		return err
	}
	_, err = r.pool.Exec(ctx, `INSERT INTO self.improvement_needs(improvement_need_id,principal_id,subject_ref,problem_summary,evidence_refs,expected_benefit,priority,state,created_at_unix_millis)
		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, subject, value.ProblemSummary, evidence, value.ExpectedBenefit, value.Priority, value.State, value.CreatedAt)
	return err
}

func (r *SelfRepository) SaveLearningLedger(ctx context.Context, value selfcontract.LearningLedgerEntry) error {
	evidence, err := json.Marshal(value.EvidenceRefs)
	if err != nil {
		return err
	}
	improvement, err := json.Marshal(value.ImprovementNeedRef)
	if err != nil {
		return err
	}
	proposed, err := json.Marshal(value.ProposedChangeRef)
	if err != nil {
		return err
	}
	evaluations, err := json.Marshal(value.ActualEvaluationRefs)
	if err != nil {
		return err
	}
	gate, err := json.Marshal(value.DevelopmentGateRef)
	if err != nil {
		return err
	}
	before, err := json.Marshal(value.BeforeVersionRefs)
	if err != nil {
		return err
	}
	after, err := json.Marshal(value.AfterVersionRefs)
	if err != nil {
		return err
	}
	sideEffects, err := json.Marshal(value.SideEffects)
	if err != nil {
		return err
	}
	rollback, err := json.Marshal(value.RollbackRef)
	if err != nil {
		return err
	}
	_, err = r.pool.Exec(ctx, `INSERT INTO self.learning_ledger(entry_id,principal_id,improvement_need_ref,observed_problem,evidence_refs,diagnosis,hypothesis,proposed_change_ref,expected_improvement,evaluation_refs,development_gate_ref,before_version_refs,after_version_refs,decision,side_effects,rollback_ref,recorded_at_unix_millis)
		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, improvement, value.ObservedProblem, evidence, value.Diagnosis, value.Hypothesis, proposed, value.ExpectedImprovement, evaluations, gate, before, after, value.Decision, sideEffects, rollback, value.RecordedAt)
	return err
}

func (r *SelfRepository) SaveLearningSignal(ctx context.Context, value selfcontract.LearningSignal) error {
	if err := value.Validate(); err != nil {
		return err
	}
	subject, err := json.Marshal(value.SubjectRef)
	if err != nil {
		return err
	}
	evidence, err := json.Marshal(value.EvidenceRefs)
	if err != nil {
		return err
	}
	deps, err := json.Marshal(value.DependencyRefs)
	if err != nil {
		return err
	}
	_, err = r.pool.Exec(ctx, `INSERT INTO self.learning_signals(signal_id,principal_id,kind,task_pattern,scope_key,subject_ref,evidence_refs,expected_outcome,actual_outcome,dependency_refs,environment_version,observed_at_unix_millis,severity,user_impact,correction_count,decision_regret)
		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, value.Kind, value.TaskPattern, value.ScopeKey, subject, evidence, value.ExpectedOutcome, value.ActualOutcome, deps, value.EnvironmentVersion, value.ObservedAt, value.Severity, value.UserImpact, value.CorrectionCount, value.DecisionRegret)
	return err
}

func (r *SelfRepository) SaveWeaknessPattern(ctx context.Context, value selfcontract.WeaknessPattern) error {
	evidence, err := json.Marshal(value.DetectionEvidenceRefs)
	if err != nil {
		return err
	}
	deps, err := json.Marshal(value.DependencyRefs)
	if err != nil {
		return err
	}
	_, err = r.pool.Exec(ctx, `INSERT INTO self.weakness_patterns(assessment_id,principal_id,revision,pattern_key,task_pattern,scope_key,environment_version,dependency_refs,failure_mode,detection_evidence_refs,frequency,last_observed_at_unix_millis,severity,affected_component,affected_strategy,confidence_millis,epistemic_status,state,recorded_at_unix_millis)
		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, value.Revision, value.PatternKey, value.TaskPattern, value.ScopeKey, value.EnvironmentVersion, deps, value.FailureMode, evidence, value.Frequency, value.LastObservedAt, value.Severity, value.AffectedComponent, value.AffectedStrategy, value.ConfidenceMillis, value.EpistemicStatus, value.State, value.RecordedAt)
	return err
}

func (r *SelfRepository) SaveImprovementCandidate(ctx context.Context, value selfcontract.ImprovementCandidate) error {
	if err := value.Validate(); err != nil {
		return err
	}
	need, err := json.Marshal(value.NeedRef)
	if err != nil {
		return err
	}
	must, err := json.Marshal(value.MustNotWorsen)
	if err != nil {
		return err
	}
	evidence, err := json.Marshal(value.EvidenceRefs)
	if err != nil {
		return err
	}
	_, err = r.pool.Exec(ctx, `INSERT INTO self.improvement_candidates(candidate_id,principal_id,need_ref,hypothesis,expected_effect,evaluation_plan,must_not_worsen,rollback_plan,resource_cost,creator,independent_evaluator,state,evidence_refs,created_at_unix_millis)
		VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, need, value.Hypothesis, value.ExpectedEffect, value.EvaluationPlan, must, value.RollbackPlan, value.ResourceCost, value.Creator, value.IndependentEvaluator, value.State, evidence, value.CreatedAt)
	return err
}

func (r *SelfRepository) SaveBenchmarkCase(ctx context.Context, value selfcontract.BenchmarkCase) error {
	if !value.Valid() {
		return fmt.Errorf("benchmark case is incomplete")
	}
	evidence, err := json.Marshal(value.EvidenceRefs)
	if err != nil {
		return err
	}
	_, err = r.pool.Exec(ctx, `INSERT INTO self.personal_benchmark_cases(case_id,principal_id,task_class,evidence_refs,recorded_at_unix_millis) VALUES($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, value.TaskClass, evidence, value.RecordedAt)
	return err
}