import type {
  MolrooWorldConfig,
  CreateWorldInput,
  WorldDefinitionInput,
  EntityInput,
  SpaceInput,
  EnvironmentInput,
  WorldInteractionOptions,
  PersonaConfigData,
  UserProfile,
} from '@molroo-ai/sdk';

interface MolrooWorldConfig {
  baseUrl: string;
  apiKey: string;
  worldId?: string;
}

{
  baseUrl: string;
  apiKey: string;
  llm?: LLMAdapter;       // LLM adapter for generating responses
  storage?: StorageAdapter; // Storage adapter for snapshot backup
  memory?: MemoryAdapter;   // Memory adapter for episode persistence
  events?: EventAdapter;    // Event adapter for SDK-level event emission
}

interface CreateWorldInput {
  definition: WorldDefinitionInput;
  entities: EntityInput[];
  spaces?: SpaceInput[];
  environment?: Partial<EnvironmentInput>;
  personaConfigs: Record<string, Record<string, unknown>>;
  interaction?: WorldInteractionOptions;
}

const setup: CreateWorldInput = {
  definition: {
    identity: { name: 'Moonlight Academy', genre: 'school', tone: 'dramatic' },
    rules: {
      social: { norms: ['respect seniors', 'no fighting in hallways'] },
      narrative: { consequenceSpeed: 'moderate' },
    },
    culture: {
      coreValues: ['honor', 'friendship', 'growth'],
    },
  },
  entities: [
    { name: 'user', type: 'user' },
    { name: 'Sera', type: 'persona', spaceId: 'classroom' },
    { name: 'Mika', type: 'persona', spaceId: 'library' },
  ],
  spaces: [
    { name: 'classroom', type: 'physical', capacity: 30 },
    { name: 'library', type: 'physical', capacity: 20 },
    { name: 'courtyard', type: 'physical', capacity: 50 },
  ],
  environment: { weather: 'sunny', location: 'hilltop campus', ambiance: 'cheerful' },
  personaConfigs: {
    Sera: {
      identity: { name: 'Sera', role: 'student council president' },
      personality: { O: 0.7, C: 0.8, E: 0.6, A: 0.9, N: 0.3, H: 0.8 },
    },
    Mika: {
      identity: { name: 'Mika', role: 'quiet bookworm' },
      personality: { O: 0.9, C: 0.5, E: 0.3, A: 0.7, N: 0.6, H: 0.7 },
    },
  },
  interaction: {
    groupAwareness: true,
    emotionalContagion: true,
    propagation: 'same-space',
  },
};

interface WorldDefinitionInput {
  identity?: {
    name: string;
    genre?: string;
    era?: string;
    tone?: string;
    lore?: string;
  };
  rules?: {
    physics?: {
      canFly?: boolean;
      canTeleport?: boolean;
      deathIsPermanent?: boolean;
      magicExists?: boolean;
    };
    social?: {
      norms?: string[];
      taboos?: string[];
      hierarchies?: string[];
    };
    narrative?: {
      tone?: string;
      violenceLevel?: string;
      romanceLevel?: string;
      consequenceSpeed?: string;
    };
  };
  culture?: {
    coreValues?: string[];
    normMap?: Record<string, number>;
    socialProtocol?: {
      greetingStyle?: string;
      addressSystem?: string;
      tabooTopics?: string[];
    };
  };
  topology?: {
    connections?: SpaceConnection[];
  };
  time?: Record<string, unknown>;
  knowledge?: {
    facts?: Fact[];
    defaultVisibility?: string;
  };
  progression?: {
    initialPhase?: string;
    phases?: Record<string, { description?: string; normMapOverride?: Record<string, number> }>;
    triggers?: ProgressionTrigger[];
  };
}

interface EntityInput {
  name: string;
  type: EntityType;   // 'persona' | 'user' | 'secondary'
  profile?: UserProfile;
  spaceId?: string;
}

interface SpaceInput {
  name: string;
  type?: SpaceType;    // 'physical' | 'virtual' | 'abstract'
  capacity?: number;
}

interface EnvironmentInput {
  weather?: string;
  location?: string;
  ambiance?: string;
  [key: string]: unknown;  // Extensible
}

interface WorldInteractionOptions {
  groupAwareness?: boolean;
  emotionalContagion?: boolean;
  propagation?: 'none' | 'same-space' | 'adjacent';
}

interface PersonaConfigData {
  personality?: Record<string, number>;   // HEXACO: { O, C, E, A, N, H }
  identity?: Record<string, unknown>;     // name, role, speakingStyle, coreValues
  goals?: Array<Record<string, unknown>>; // { id, content, priority, status, mutable }
  [key: string]: unknown;                 // Extensible
}

interface UserProfile {
  displayName?: string;
  role?: string;
  description?: string;
  personalityHints?: string;
}