import type {
  ChatOptions,
  ChatInput,
  EventInput,
  MutateOp,
  RelationshipInput,
  TimeJumpInput,
  QueryInclude,
} from '@molroo-ai/sdk';

interface ChatOptions {
  from?: string;
  appraisal?: AppraisalVector;
  includeState?: boolean;
  history?: Array<{ role: 'user' | 'assistant'; content: string }>;
  propagateToSpace?: boolean;
}

// With conversation history
const result = await world.chat('Sera', 'Do you remember what we talked about?', {
  history: [
    { role: 'user', content: 'I love coffee!' },
    { role: 'assistant', content: 'Oh really? What kind do you prefer?' },
  ],
});

// Whisper (no observers even if groupAwareness is on)
const result2 = await world.chat('Sera', 'Can I tell you a secret?', {
  propagateToSpace: false,
});

// Emotion-only mode with manual appraisal
const result3 = await world.chat('Sera', 'You look nice today', {
  appraisal: {
    goal_relevance: 0.4,
    goal_congruence: 0.7,
    expectedness: 0.5,
    controllability: 0.3,
    agency: -0.5,
    norm_compatibility: 0.8,
  },
});

interface ChatInput {
  from: string;
  to: string;
  message: string;
  appraisal?: AppraisalVector;
}

interface EventInput {
  type: string;
  target?: string;
  from?: string;
  payload?: Record<string, unknown>;
  appraisal?: AppraisalVector;
  stimulus?: {
    bodyBudgetDelta?: number;
    vadOverride?: Partial<{ V: number; A: number; D: number }>;
    vadDelta?: Partial<{ V: number; A: number; D: number }>;
    needsDelta?: Partial<{ autonomy: number; competence: number; relatedness: number }>;
    soulStageForce?: number;
    catastropheAlphaDelta?: number;
  };
  propagateToAdjacent?: boolean;
}

await world.event({
  type: 'surprise_gift',
  target: 'Sera',
  from: 'user',
  payload: { item: 'flowers', description: 'A beautiful bouquet of roses' },
  appraisal: {
    goal_relevance: 0.6,
    goal_congruence: 0.9,
    expectedness: 0.2,
    controllability: 0.3,
    agency: -0.8,
    norm_compatibility: 0.9,
  },
});

// Exhaustion event — drains body budget and lowers arousal
await world.event({
  type: 'exhaustion',
  target: 'Sera',
  stimulus: {
    bodyBudgetDelta: -0.3,
    vadDelta: { A: -0.4, V: -0.1 },
    needsDelta: { competence: -0.2 },
  },
});

// No target — affects all entities in the default space
await world.event({
  type: 'fire_alarm',
  payload: { severity: 'high' },
  appraisal: {
    goal_relevance: 0.9,
    goal_congruence: -0.8,
    expectedness: 0.1,
    controllability: 0.2,
    agency: -1,
    norm_compatibility: 0,
  },
  propagateToAdjacent: true,
});

type MutateOp =
  | { op: 'add_entity'; name: string; type: EntityType; profile?: UserProfile; spaceId?: string }
  | { op: 'add_agent'; name: string; config: Record<string, unknown>; spaceId?: string }
  | { op: 'remove_entity'; target: string }
  | { op: 'move_entity'; target: string; toSpace: string }
  | { op: 'set_emotion'; target: string; vad: Partial<VAD> }
  | { op: 'set_relationship'; entityA: string; entityB: string; relationship: RelationshipInput }
  | { op: 'add_space'; name: string; spaceType?: SpaceType; capacity?: number }
  | { op: 'add_connection'; connection: SpaceConnection }
  | { op: 'remove_connection'; from: string; to: string }
  | { op: 'update_connection'; from: string; to: string; updates: { accessibility?: string } }
  | { op: 'update_environment'; environment: Partial<EnvironmentInput> }
  | { op: 'add_fact'; fact: Fact }
  | { op: 'reveal_fact'; factId: string; entities: string[] }
  | { op: 'hide_fact'; factId: string; entities: string[] }
  | { op: 'set_phase'; phase: string }
  | { op: 'add_trigger'; trigger: ProgressionTrigger }

await world.mutate([
  // Add a new character
  { op: 'add_entity', name: 'Kai', type: 'persona', spaceId: 'courtyard' },

  // Connect spaces
  { op: 'add_connection', connection: { from: 'courtyard', to: 'library', bidirectional: true } },

  // Add a secret fact
  {
    op: 'add_fact',
    fact: { id: 'secret-1', content: 'Kai is secretly a prince', visibility: 'secret', knownBy: ['Kai'] },
  },

  // Reveal the fact to Sera
  { op: 'reveal_fact', factId: 'secret-1', entities: ['Sera'] },

  // Set emotion directly
  { op: 'set_emotion', target: 'Sera', vad: { V: 0.5, A: 0.3 } },

  // Add a phase transition trigger
  {
    op: 'add_trigger',
    trigger: {
      id: 'reveal-arc',
      condition: { type: 'relationship', entityA: 'Kai', entityB: 'Sera', field: 'trust', above: 0.8 },
      targetPhase: 'truth_revealed',
      oneShot: true,
    },
  },
]);

interface RelationshipInput {
  type: string;
  strength?: number;
  trust?: number;
}

interface TimeJumpInput {
  seconds: number;
  milestoneEvent?: Record<string, unknown>;
}

type QueryInclude = 'entities' | 'spaces' | 'environment' | 'definition' | 'phase';

// Get only entities and current phase
const { entities, currentPhase } = await world.query(['entities', 'phase']);

// Get everything
const all = await world.query();
// or equivalently:
const all2 = await world.query(['entities', 'spaces', 'environment', 'definition', 'phase']);