import { createProfileEngine } from 'ri-guardrails';
import type { ProfileEvent, CheckContext } from 'ri-guardrails';

// 1. Create an engine (deterministic IDs for reproducibility)
let counter = 0;
const engine = createProfileEngine({
  idGenerator: () => `id-${String(++counter)}`,
});

// 2. Synthesize a profile from event history
const events: ProfileEvent[] = [
  {
    id: 'e1', type: 'user_feedback', timestamp: '2024-01-01T00:00:00Z',
    payload: { sentiment: 'positive', category: 'ui_style', value: 'dark_mode' },
  },
  {
    id: 'e2', type: 'user_feedback', timestamp: '2024-01-02T00:00:00Z',
    payload: { sentiment: 'negative', category: 'charts', value: 'pie chart' },
  },
];
const profile = engine.synthesize(events);

// 3. Record additional signals incrementally
engine.recordPreference({
  category: 'ui_style', value: 'dark_mode',
  signalType: 'explicit_approval', timestamp: '2024-01-03T00:00:00Z',
});
engine.recordRejection({
  category: 'charts', pattern: 'pie chart',
  signalType: 'explicit_rejection', timestamp: '2024-01-03T00:00:00Z',
});

// 4. Evaluate a proposed action through the three-check pipeline
const context: CheckContext = {
  clarity: { pass: true, reason: null },
  feasibility: { pass: true, reason: null },
  proposedAction: 'create',
  proposedFeatures: ['bar chart', 'dark mode'],
  currentTimestamp: '2024-01-03T00:00:00Z',
};
const result = engine.evaluate(context);

if (result.action === 'proceed') {
  // Safe to proceed — no conflicts detected
} else {
  // Blocked — check result.blockReason and result.alternatives
  console.log(`Blocked: ${result.blockReason}`);
}

// 5. Record the user's response for calibration
engine.recordOutcome({
  checkResultId: result.calibrationEvent.id,
  userAction: 'accepted',
  timestamp: '2024-01-03T00:00:00Z',
});

interface ProfileEngine {
  synthesize(events: readonly ProfileEvent[]): UserProfile;
  evaluate(context: CheckContext): CheckResult;
  recordPreference(signal: Omit<PreferenceSignal, 'id'>): void;
  recordRejection(signal: Omit<RejectionSignal, 'id'>): void;
  recordOutcome(calibration: CalibrationOutcome): void;
  getConfig(): ProfileConfig;
  updateConfig(patch: Partial<ProfileConfig>): void;
}

interface UserProfile {
  readonly preferences: readonly PreferenceEntry[];
  readonly rejections: readonly RejectionEntry[];
  readonly vocabulary: readonly VocabularyMapping[];
  readonly patterns: readonly BehaviorPattern[];
  readonly weights: WeightVector;
  readonly synthesizedAt: string;   // ISO 8601
  readonly eventCount: number;
}

interface ProfileEvent {
  readonly id: string;
  readonly type: string;
  readonly timestamp: string;          // ISO 8601
  readonly payload: Readonly<Record<string, unknown>>;
}

interface PreferenceSignal {
  readonly id: string;
  readonly category: string;
  readonly value: string;
  readonly signalType: PreferenceSignalType;
  readonly timestamp: string;
}

interface RejectionSignal {
  readonly id: string;
  readonly category: string;
  readonly pattern: string;
  readonly signalType: RejectionSignalType;
  readonly timestamp: string;
}

interface CheckContext {
  readonly clarity: { readonly pass: boolean; readonly reason: string | null };
  readonly feasibility: { readonly pass: boolean; readonly reason: string | null };
  readonly proposedAction: string;
  readonly proposedFeatures: readonly string[];
  readonly currentTimestamp: string;    // ISO 8601 — for decay calculation
}

interface CheckResult {
  readonly checks: {
    readonly clarity: { readonly pass: boolean; readonly reason: string | null };
    readonly profileConflict: { readonly pass: boolean; readonly conflicts: readonly ConflictDetail[] };
    readonly feasibility: { readonly pass: boolean; readonly reason: string | null };
  };
  readonly action: 'proceed' | 'block';
  readonly blockReason?: 'clarity' | 'profile_conflict' | 'feasibility';
  readonly alternatives?: readonly string[];
  readonly profileSnapshot: UserProfile;
  readonly calibrationEvent: CalibrationEvent;
}

interface CalibrationOutcome {
  readonly checkResultId: string;
  readonly userAction: 'accepted' | 'rejected' | 'overridden' | 'rephrased';
  readonly timestamp: string;
}

interface CalibrationEvent {
  readonly id: string;
  readonly checkResult: CheckResult;
  readonly outcome: CalibrationOutcome | null;  // null until outcome recorded
}

interface ProfileConfig {
  readonly preferenceHalfLifeDays: number;        // default: 90
  readonly softRejectionHalfLifeDays: number;     // default: 60
  readonly patternHalfLifeDays: number;           // default: 120
  readonly hardBlockThreshold: number;            // default: 3
  readonly rejectionSimilarityThreshold: number;  // default: 0.7
  readonly softConflictBlockThreshold: number;    // default: 2
  readonly similarityStrategy: SimilarityStrategy; // default: 'jaro-winkler'
}

type SimilarityStrategy = 'levenshtein' | 'jaro-winkler';

type GuardrailsError =
  | { readonly code: 'INVALID_EVENT'; readonly reason: string }
  | { readonly code: 'INVALID_SIGNAL'; readonly reason: string }
  | { readonly code: 'CONFIG_ERROR'; readonly field: string; readonly reason: string }
  | { readonly code: 'SYNTHESIS_ERROR'; readonly reason: string };

type Result<T, E> =
  | { readonly ok: true; readonly value: T }
  | { readonly ok: false; readonly error: E };

import {
  computeDecay,
  daysBetween,
  applyDecayToPreference,
  applyDecayToRejection,
  applyDecayToPattern,
} from 'ri-guardrails';

import {
  computeSimilarity,
  findMatchingRejections,
  levenshteinDistance,
  levenshteinSimilarity,
  jaroSimilarity,
  jaroWinklerSimilarity,
  normalize,
  tokenize,
  removePunctuation,
  tokenSortNormalize,
} from 'ri-guardrails';

import {
  synthesize,
  classifyEvent,
  classifyEvents,
  aggregatePreferences,
  aggregateRejections,
  extractVocabulary,
  detectPatterns,
  PREFERENCE_STRENGTH,
  REJECTION_STRENGTH,
} from 'ri-guardrails';

const events: ProfileEvent[] = [
  { id: '1', type: 'user_feedback', timestamp: '2024-01-01T00:00:00Z',
    payload: { sentiment: 'positive', category: 'ui_style', value: 'dark_mode' } },
  { id: '2', type: 'space_created', timestamp: '2024-01-02T00:00:00Z',
    payload: { features: ['grid_layout', 'charts'] } },
  { id: '3', type: 'vocabulary_usage', timestamp: '2024-01-03T00:00:00Z',
    payload: { userPhrase: 'make it pop', systemMeaning: 'increase_contrast' } },
];

const config: ProfileConfig = {
  preferenceHalfLifeDays: 90,
  softRejectionHalfLifeDays: 60,
  patternHalfLifeDays: 120,
  hardBlockThreshold: 3,
  rejectionSimilarityThreshold: 0.7,
  softConflictBlockThreshold: 2,
  similarityStrategy: 'jaro-winkler',
};

const profile = synthesize(events, config);
// profile.preferences — aggregated with decay
// profile.rejections — fuzzy-matched and hard-blocked
// profile.vocabulary — phrase→meaning mappings
// profile.patterns — frequency-based behavioral patterns
// profile.weights — derived from pattern strengths

const PREFERENCE_STRENGTH = {
  first_attempt_confirm: 0.1,
  explicit_approval: 0.3,
  repeated_usage: 0.2,
  evolve_add: 0.2,
} as const;

const REJECTION_STRENGTH = {
  evolve_remove: 0.2,
  explicit_rejection: 0.3,
  repeated_rejection: 0.3,
} as const;

import {
  recordPreference,
  recordRejection,
  recordOutcome,
} from 'ri-guardrails';

import {
  evaluate,
  checkClarity,
  checkFeasibility,
  checkProfile,
  generateAlternatives,
} from 'ri-guardrails';

import { createProfileEngine } from 'ri-guardrails';

const engine = createProfileEngine({
  config: { preferenceHalfLifeDays: 30 },
  idGenerator: () => crypto.randomUUID(), // caller controls IDs
});

// Full profile synthesis from events
const profile = engine.synthesize(events);

// Incremental updates
engine.recordPreference({ category: 'ui_style', value: 'dark_mode', signalType: 'explicit_approval', timestamp });
engine.recordRejection({ category: 'charts', pattern: 'pie charts', signalType: 'explicit_rejection', timestamp });

// Evaluate proposed actions against the profile
const result = engine.evaluate(context);

// Record user outcome for calibration
engine.recordOutcome({ checkResultId: result.calibrationEvent.id, userAction: 'accepted', timestamp });

// Configuration management
engine.updateConfig({ softConflictBlockThreshold: 3 });
const config = engine.getConfig();