import { Molroo } from '@molroo-io/sdk';
import { createOpenAI } from '@ai-sdk/openai';

const molroo = new Molroo({ apiKey: 'mk_live_xxx' });

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY! });

const persona = await molroo.createPersona(
  {
    identity: { name: 'Sera', role: 'barista', speakingStyle: 'warm and casual' },
    personality: { O: 0.7, C: 0.6, E: 0.8, A: 0.9, N: 0.3, H: 0.8 },
  },
  { llm: openai('gpt-4o-mini') },
);

// Chat with external history management
let history: Message[] = [];
const result = await persona.chat('Good morning! What do you recommend?', { history });
console.log(result.text);                      // LLM-generated response
console.log(result.response.emotion);          // { V: 0.65, A: 0.42, D: 0.38 }
history = result.updatedHistory;               // Save for next call

// From description (requires llm)
const persona = await MolrooPersona.create(
  { apiKey: 'mk_live_xxx', llm: openai('gpt-4o-mini') },
  'A kind and curious barista who remembers customer names',
);

// From explicit config
const persona = await MolrooPersona.create(
  { apiKey: 'mk_live_xxx', llm: openai('gpt-4o-mini') },
  {
    identity: { name: 'Sera', role: 'barista' },
    personality: { O: 0.7, C: 0.6, E: 0.8, A: 0.9, N: 0.3, H: 0.8 },
  },
);

const persona = await MolrooPersona.connect(
  { apiKey: 'mk_live_xxx', llm: openai('gpt-4o-mini') },
  'persona_abc123',
);

const { personas } = await MolrooPersona.listPersonas({
  apiKey: 'mk_live_xxx',
});

type ReactInput =
  | { kind: 'perceive'; message: string; [key: string]: unknown }
  | { kind: 'hear'; message: string; from: string; [key: string]: unknown }
  | { kind: 'experience'; description: string; appraisal: AppraisalVector; [key: string]: unknown }
  | { kind: 'event'; type: string; description: string; appraisal: AppraisalVector; [key: string]: unknown }
  | { kind: 'socialize'; message: string; from: string; relationship: { trust: number; familiarity: number }; [key: string]: unknown }

const response = await persona.react({
  kind: 'perceive',
  message: 'You did a great job!',
});
console.log(response.emotion); // { V: 0.7, A: 0.5, D: 0.3 }

const response = await persona.react({
  kind: 'hear',
  message: 'Good morning! What do you recommend today?',
  from: 'Alice',
});

const response = await persona.react({
  kind: 'experience',
  description: 'A beautiful sunset over the ocean.',
  appraisal: {
    goal_relevance: 0.3,
    goal_congruence: 0.8,
    expectedness: 0.4,
    controllability: 0.0,
    agency: -1,
    norm_compatibility: 1,
    internal_standards: 0.9,
    adjustment_potential: 0.8,
    urgency: 0.0,
  },
});

const response = await persona.react({
  kind: 'event',
  type: 'gift_received',
  description: 'A customer left flowers on the counter.',
  appraisal: {
    goal_relevance: 0.6,
    goal_congruence: 0.9,
    expectedness: 0.2,
    controllability: 0.0,
    agency: -1,
    norm_compatibility: 1,
    internal_standards: 0.8,
    adjustment_potential: 0.9,
    urgency: 0.0,
  },
});

const response = await persona.react({
  kind: 'socialize',
  message: 'I missed you while I was away.',
  from: 'Bob',
  relationship: { trust: 0.8, familiarity: 0.9 },
});

interface PersonaUpdate {
  emotion?:       Partial<{ V: number; A: number; D: number }>;
  annotation?:    string;
  nextResponse?:  string;
  styleProfile?:  StyleProfile;
  config?:        PersonaConfigData;
  snapshot?:      PersonaSnapshot;
}

// Set emotion and prime a response in one round-trip
await persona.update({
  emotion: { V: 0.5, A: 0.3 },
  nextResponse: 'Good morning! The usual?',
});

// Full state reset from snapshot with updated config
await persona.update({
  snapshot: savedSnapshot,
  config: {
    identity: { name: 'Sera', role: 'head barista' },
  },
});

let history: Message[] = [];

const result = await persona.chat('How are you feeling today?', {
  from: 'Alex',
  history,
});

console.log(result.text);                        // LLM-generated text
console.log(result.response.emotion);            // { V: 0.6, A: 0.4, D: 0.3 }
console.log(result.state?.mood);                 // slow-moving baseline mood
console.log(result.updatedHistory);              // updated conversation history

// Save history for next call
history = result.updatedHistory;

interface PersonaChatResult {
  /** LLM-generated response text. */
  text: string;
  /** Emotion engine response with VAD, discrete emotion, and side effects. */
  response: AgentResponse;
  /** Persona state at the time of interaction (if available). */
  state?: PersonaState;
  /** Updated conversation history including this turn. Manage externally. */
  updatedHistory: Message[];
}

const result = await persona.chat('Hello traveler!', {
  from: {
    name: 'Kim',
    description: 'A weary traveler who just arrived at the tavern.',
    extensions: {
      inventory: 'sword, healing potion',
      quest: 'Find the lost artifact of Eldoria',
    },
  },
  history,
});
history = result.updatedHistory;

await persona.tick(3600); // Advance 1 hour

const state = await persona.getState();
console.log(state.emotion);    // { V: 0.3, A: 0.2, D: 0.1 }
console.log(state.mood);       // slow-changing mood baseline
console.log(state.somatic);    // somatic marker descriptions

const ctx = await persona.getPromptContext('Be extra helpful today.', 'Alex');
console.log(ctx.systemPrompt);    // Full system prompt with emotion context
console.log(ctx.personaPrompt);   // Raw persona prompt data
console.log(ctx.tools);           // Available tools (if configured)

┌─────────────────────────────────────────────────┐
│ Identity                                        │
│  Name, role, core values, speaking style,       │
│  description, extensions                        │
├─────────────────────────────────────────────────┤
│ Behavioral Instructions                         │
│  "Stay in character", "Embody your              │
│  psychological state", language matching         │
├─────────────────────────────────────────────────┤
│ ## Current Psychological State                  │
│  • Emotion (VAD → natural language)    always   │
│  • Mood (slow-changing baseline)       if set   │
│  • Somatic markers (body sensations)   if set   │
│  • Goals & motivations                 if set   │
│  • Narrative arc & self-perception     if set   │
│  • Memory context (past interactions)  if source│
├─────────────────────────────────────────────────┤
│ ## Expression Style            if StyleProfile  │
│  • Message length constraints                   │
│  • Formality level                              │
│  • Emoji/laugh/punctuation guidance             │
│  • Signature expressions & sentence endings     │
│  • Forbidden patterns                           │
│  • Emotion-driven modulation reasons            │
├─────────────────────────────────────────────────┤
│ Consumer Suffix                     if provided │
│  (your app-specific context goes here)          │
└─────────────────────────────────────────────────┘

const snapshot = await persona.getSnapshot();

const profile = await persona.extractStyleProfile([
  'omg that latte art is gorgeous!!',
  'haha yeah i always double-shot my espressos~',
  // ... 20-30 messages recommended
]);

await persona.destroy();

await persona.restore();

interface PersonaConfigData {
  personality?: PersonalityTraits;   // 6-factor: { O, C, E, A, N, H }
  identity?: Identity;               // name, role, speakingStyle, coreValues
  goals?: Goal[];                    // persona goals and motivations
  [key: string]: unknown;            // extensible
}

const response = await persona.perceive('You did a great job!', {
  from: 'Alex',
  appraisal: {
    goal_relevance: 0.8,
    goal_congruence: 0.9,
    expectedness: 0.3,
    controllability: 0.2,
    agency: -0.7,
    norm_compatibility: 0.9,
    internal_standards: 0.8,
    adjustment_potential: 0.7,
    urgency: 0.1,
  },
});

console.log(response.emotion); // { V: 0.7, A: 0.5, D: 0.3 }

await persona.hear('Good morning!', 'Alice');

await persona.experience('A beautiful sunset.', {
  goal_relevance: 0.3,
  goal_congruence: 0.8,
  expectedness: 0.4,
  controllability: 0.0,
  agency: -1,
  norm_compatibility: 1,
  internal_standards: 0.9,
  adjustment_potential: 0.8,
  urgency: 0.0,
});

await persona.event('breaking_news', 'A major earthquake struck the region.', {
  appraisal: {
    goal_relevance: 0.7,
    goal_congruence: -0.6,
    expectedness: 0.1,
    controllability: 0.0,
    agency: -1,
    norm_compatibility: 0,
    internal_standards: 0,
    adjustment_potential: 0.2,
    urgency: 0.9,
  },
});

await persona.socialize('I missed you.', 'Bob', { trust: 0.8, familiarity: 0.9 });

await persona.setEmotion({ V: -0.5, A: 0.8 }); // Set to anxious state

await persona.annotate('is cheerful today');

await persona.setNextResponse('OK!');

await persona.setStyleProfile(profile);

await persona.patch({
  config: {
    identity: { name: 'Sera', role: 'head barista' },
    personality: { O: 0.7, C: 0.7, E: 0.8, A: 0.9, N: 0.3, H: 0.8 },
  },
});

await persona.putSnapshot(savedSnapshot);