interface BlackTrigramDataItem {
  // Partition Key: Entity type + ID
  PK: string;  // Format: "PLAYER#<userId>" | "GAME#<gameId>" | "ACHIEVEMENT#<achievementId>"
  
  // Sort Key: Sub-entity type + ID/timestamp
  SK: string;  // Format: "PROFILE" | "GAMESTATE#<timestamp>" | "ACHIEVEMENT#<achievementId>" | "PURCHASE#<purchaseId>"
  
  // Attributes (entity-specific)
  [key: string]: any;
}

/**
 * Player profile stored in DynamoDB
 * 플레이어 프로필 (Player Profile)
 */
export interface PlayerProfileItem {
  // Primary Keys
  readonly PK: `PLAYER#${string}`;  // PLAYER#<userId>
  readonly SK: "PROFILE";
  
  // Player Identity
  readonly userId: string;           // UUID v4
  readonly username: string;         // Display name (unique)
  readonly email: string;            // Email address (unique)
  readonly cognitoSub: string;       // AWS Cognito user ID
  
  // Profile Data
  readonly archetype: PlayerArchetype;  // Combat archetype
  readonly level: number;               // Player level (1-100)
  readonly experience: number;          // Total XP earned
  readonly totalPlayTime: number;       // Total seconds played
  
  // Statistics
  readonly matchesPlayed: number;
  readonly matchesWon: number;
  readonly totalDamageDealt: number;
  readonly totalDamageReceived: number;
  readonly vitalPointHits: number;
  readonly perfectStrikes: number;
  
  // Timestamps
  readonly createdAt: string;        // ISO 8601 timestamp
  readonly updatedAt: string;        // ISO 8601 timestamp
  readonly lastLogin: string;        // ISO 8601 timestamp
  
  // Data Version
  readonly version: number;          // Schema version (for migrations)
  readonly dataVersion: string;      // Semantic version (e.g., "1.0.0")
  
  // GSI Attributes (for leaderboard queries)
  readonly GSI1PK?: `LEADERBOARD#${string}`;  // LEADERBOARD#<archetype>
  readonly GSI1SK?: `SCORE#${number}`;        // SCORE#-123456 (negative for desc sort)
}

/**
 * Game state snapshot stored in DynamoDB
 * 게임 상태 (Game State)
 */
export interface GameStateItem {
  // Primary Keys
  readonly PK: `PLAYER#${string}`;       // PLAYER#<userId>
  readonly SK: `GAMESTATE#${string}`;    // GAMESTATE#<timestamp>
  
  // Game State Data
  readonly userId: string;
  readonly gameStateId: string;          // UUID for this game state
  
  // Combat State
  readonly currentStance: TrigramStance;
  readonly health: number;
  readonly maxHealth: number;
  readonly ki: number;
  readonly maxKi: number;
  readonly stamina: number;
  readonly maxStamina: number;
  
  // Stance Progress
  readonly stanceData: readonly {
    readonly stance: TrigramStance;
    readonly masteryLevel: number;      // 0-100
    readonly techniquesUnlocked: readonly string[];
    readonly practiceTime: number;      // seconds
  }[];
  
  // Vital Point Progress
  readonly vitalPointProgress: readonly {
    readonly vitalPointId: string;
    readonly timesHit: number;
    readonly successRate: number;       // 0.0-1.0
    readonly bestAccuracy: number;      // 0.0-1.0
  }[];
  
  // Equipment/Cosmetics
  readonly equipment: readonly {
    readonly slot: string;
    readonly itemId: string;
    readonly purchasedAt: string;
  }[];
  
  // Match Context (if saved during match)
  readonly isInMatch: boolean;
  readonly opponentArchetype?: PlayerArchetype;
  readonly matchStartTime?: string;
  
  // Metadata
  readonly timestamp: string;            // ISO 8601
  readonly version: number;              // Schema version
  readonly dataVersion: string;          // Semantic version
  
  // Compression flag (for large game states)
  readonly compressed?: boolean;
  readonly compressionAlgo?: "gzip" | "brotli";
}

/**
 * Player achievement record in DynamoDB
 * 업적 (Achievement)
 */
export interface AchievementItem {
  // Primary Keys
  readonly PK: `PLAYER#${string}`;         // PLAYER#<userId>
  readonly SK: `ACHIEVEMENT#${string}`;    // ACHIEVEMENT#<achievementId>
  
  // Achievement Data
  readonly userId: string;
  readonly achievementId: string;          // e.g., "vital_point_master_50"
  readonly name: KoreanText;
  readonly description: KoreanText;
  readonly category: AchievementCategory;
  
  // Progress Tracking
  readonly progress: number;               // Current progress (0-100)
  readonly requiredProgress: number;       // Target for completion
  readonly isUnlocked: boolean;
  readonly unlockedAt?: string;            // ISO 8601 timestamp
  
  // Rewards
  readonly rewards: {
    readonly experience: number;
    readonly items?: readonly string[];    // Item IDs
    readonly title?: KoreanText;
  };
  
  // Metadata
  readonly version: number;
  
  // GSI Attributes (for achievement listing)
  readonly GSI2PK?: "ACHIEVEMENTS";
  readonly GSI2SK?: `DATE#${string}`;      // DATE#<unlockedAt> for sorting
}

export enum AchievementCategory {
  COMBAT = "combat",              // 전투 - Combat achievements
  VITAL_POINTS = "vital_points",  // 급소 - Vital point targeting
  STANCES = "stances",            // 자세 - Stance mastery
  MATCHES = "matches",            // 경기 - Match victories
  TRAINING = "training",          // 훈련 - Training progress
  COLLECTION = "collection",      // 수집 - Item collection
}

/**
 * Stripe purchase record in DynamoDB
 * 구매 기록 (Purchase Record)
 */
export interface PurchaseItem {
  // Primary Keys
  readonly PK: `PLAYER#${string}`;       // PLAYER#<userId>
  readonly SK: `PURCHASE#${string}`;     // PURCHASE#<purchaseId>
  
  // Purchase Identity
  readonly userId: string;
  readonly purchaseId: string;           // UUID
  readonly stripeSessionId: string;      // Stripe Checkout Session ID
  readonly stripePaymentIntentId?: string; // Stripe Payment Intent ID
  
  // Purchase Details
  readonly items: readonly {
    readonly itemId: string;
    readonly itemType: "cosmetic" | "bundle" | "premium";
    readonly quantity: number;
    readonly pricePerUnit: number;      // In cents
  }[];
  
  // Payment Info
  readonly amount: number;               // Total in cents
  readonly currency: string;             // ISO 4217 (e.g., "USD", "EUR")
  readonly status: PurchaseStatus;
  
  // Timestamps
  readonly createdAt: string;            // ISO 8601
  readonly completedAt?: string;         // ISO 8601
  readonly refundedAt?: string;          // ISO 8601
  
  // Metadata
  readonly version: number;
  
  // GSI Attributes (for purchase history queries)
  readonly GSI3PK?: "PURCHASES";
  readonly GSI3SK?: `DATE#${string}`;    // DATE#<createdAt>
}

export enum PurchaseStatus {
  PENDING = "pending",       // 대기중 - Awaiting payment
  COMPLETED = "completed",   // 완료 - Payment successful
  FAILED = "failed",         // 실패 - Payment failed
  REFUNDED = "refunded",     // 환불 - Refund processed
  EXPIRED = "expired",       // 만료 - Session expired
}

interface GSI1 {
  readonly GSI1PK: `LEADERBOARD#${PlayerArchetype}`;
  readonly GSI1SK: `SCORE#${number}`;  // Negative for descending sort
  
  // Projected attributes
  readonly userId: string;
  readonly username: string;
  readonly score: number;
  readonly archetype: PlayerArchetype;
  readonly level: number;
}

// Query top 10 players for "amsalja" archetype
const params = {
  TableName: "BlackTrigramData",
  IndexName: "GSI1",
  KeyConditionExpression: "GSI1PK = :pk",
  ExpressionAttributeValues: {
    ":pk": "LEADERBOARD#amsalja"
  },
  Limit: 10,
  ScanIndexForward: true  // Ascending = highest scores first (due to negative)
};

interface GSI2 {
  readonly GSI2PK: "ACHIEVEMENTS";
  readonly GSI2SK: `DATE#${string}`;  // DATE#<ISO 8601 timestamp>
  
  // Projected attributes
  readonly userId: string;
  readonly username: string;
  readonly achievementId: string;
  readonly achievementName: KoreanText;
  readonly unlockedAt: string;
}

interface GSI3 {
  readonly GSI3PK: "PURCHASES";
  readonly GSI3SK: `DATE#${string}`;  // DATE#<ISO 8601 timestamp>
  
  // Projected attributes
  readonly userId: string;
  readonly purchaseId: string;
  readonly amount: number;
  readonly status: PurchaseStatus;
  readonly createdAt: string;
}

interface SignupRequest {
  readonly email: string;          // Valid email format
  readonly password: string;       // Min 8 chars, 1 upper, 1 lower, 1 digit
  readonly username: string;       // 3-20 chars, alphanumeric + underscore
  readonly archetype: PlayerArchetype;
}

interface SignupResponse {
  readonly success: boolean;
  readonly userId: string;
  readonly message: string;
}

interface LoginRequest {
  readonly email: string;
  readonly password: string;
}

interface LoginResponse {
  readonly accessToken: string;    // JWT, expires in 1 hour
  readonly refreshToken: string;   // Expires in 30 days
  readonly expiresIn: number;      // Seconds until expiry
  readonly userId: string;
  readonly username: string;
  readonly archetype: PlayerArchetype;
}

interface RefreshRequest {
  readonly refreshToken: string;
}

interface RefreshResponse {
  readonly accessToken: string;
  readonly expiresIn: number;
}

interface SaveGameRequest {
  readonly userId: string;
  readonly gameState: {
    readonly currentStance: TrigramStance;
    readonly health: number;
    readonly ki: number;
    readonly stamina: number;
    readonly stanceData: readonly StanceProgressData[];
    readonly vitalPointProgress: readonly VitalPointProgressData[];
    readonly equipment: readonly EquipmentData[];
  };
}

interface SaveGameResponse {
  readonly success: boolean;
  readonly gameStateId: string;
  readonly timestamp: string;
  readonly version: number;
}

interface LoadGameResponse {
  readonly gameState: GameStateData;
  readonly savedAt: string;
  readonly version: number;
}

interface LeaderboardRequest {
  readonly archetype: PlayerArchetype | "all";
  readonly limit?: number;       // Default: 100, max: 1000
  readonly offset?: number;      // For pagination
}

interface LeaderboardResponse {
  readonly entries: readonly {
    readonly rank: number;
    readonly userId: string;
    readonly username: string;
    readonly archetype: PlayerArchetype;
    readonly score: number;
    readonly level: number;
  }[];
  readonly total: number;
  readonly nextOffset?: number;
}

interface CreateCheckoutRequest {
  readonly userId: string;
  readonly items: readonly {
    readonly itemId: string;
    readonly quantity: number;
  }[];
  readonly successUrl: string;   // Redirect after success
  readonly cancelUrl: string;    // Redirect after cancel
}

interface CreateCheckoutResponse {
  readonly sessionId: string;    // Stripe Checkout Session ID
  readonly checkoutUrl: string;  // URL to redirect user
}

interface StripeWebhookEvent {
  readonly type: string;         // "checkout.session.completed" | "payment_intent.succeeded" | etc.
  readonly data: {
    readonly object: any;        // Stripe event object
  };
}

interface WebhookResponse {
  readonly received: boolean;
}

async function saveGameState(gameState: GameState): Promise<void> {
  // Write to session storage (existing)
  sessionStorage.setItem("gameState", JSON.stringify(gameState));
  
  // Write to DynamoDB (new)
  try {
    await dynamoDB.putItem({
      TableName: "BlackTrigramData",
      Item: {
        PK: `PLAYER#${gameState.userId}`,
        SK: `GAMESTATE#${new Date().toISOString()}`,
        ...gameState,
      },
    });
  } catch (error) {
    console.error("DynamoDB write failed:", error);
    // Continue with session storage only
  }
  
  // Validate consistency (background job)
  await validateDataConsistency(gameState.userId);
}

async function loadGameState(userId: string): Promise<GameState> {
  // Try DynamoDB first
  try {
    const response = await dynamoDB.query({
      TableName: "BlackTrigramData",
      KeyConditionExpression: "PK = :pk AND begins_with(SK, :sk)",
      ExpressionAttributeValues: {
        ":pk": `PLAYER#${userId}`,
        ":sk": "GAMESTATE#",
      },
      Limit: 1,
      ScanIndexForward: false,  // Most recent first
    });
    
    if (response.Items && response.Items.length > 0) {
      return parseGameState(response.Items[0]);
    }
  } catch (error) {
    console.error("DynamoDB read failed:", error);
  }
  
  // Fallback to session storage
  const sessionData = sessionStorage.getItem("gameState");
  if (sessionData) {
    const gameState = JSON.parse(sessionData);
    
    // Migrate to DynamoDB (background)
    await migrateSessionToDynamoDB(userId, gameState);
    
    return gameState;
  }
  
  // No data found, return default
  return createDefaultGameState(userId);
}

async function syncGameState(userId: string): Promise<void> {
  // Check if online
  if (!navigator.onLine) {
    // Store in IndexedDB for offline play
    await indexedDB.setItem(`gameState_${userId}`, gameState);
    return;
  }
  
  // Sync with DynamoDB
  const localState = await indexedDB.getItem(`gameState_${userId}`);
  const cloudState = await loadGameStateFromDynamoDB(userId);
  
  // Conflict resolution: most recent timestamp wins
  const mergedState = mergeGameStates(localState, cloudState);
  
  await saveGameStateToDynamoDB(userId, mergedState);
  await indexedDB.removeItem(`gameState_${userId}`);
}

/**
 * Migrates game state from session storage to DynamoDB
 */
async function migrateSessionToDynamoDB(
  userId: string,
  sessionGameState: GameState
): Promise<void> {
  const migrationTimestamp = new Date().toISOString();
  
  // Save game state
  await dynamoDB.putItem({
    TableName: "BlackTrigramData",
    Item: {
      PK: `PLAYER#${userId}`,
      SK: `GAMESTATE#${migrationTimestamp}`,
      userId,
      gameStateId: generateUUID(),
      ...sessionGameState,
      timestamp: migrationTimestamp,
      version: 1,
      dataVersion: "1.0.0",
      migrated: true,
      migratedFrom: "session",
    },
  });
  
  // Log migration
  console.log(`Migrated game state for user ${userId}`);
  
  // Mark migration complete
  await markMigrationComplete(userId);
}

interface DataVersion {
  readonly version: number;        // Incremental version (1, 2, 3...)
  readonly dataVersion: string;    // Semantic version ("1.0.0", "1.1.0")
  readonly schemaChanges: readonly string[];
  readonly migrationRequired: boolean;
}

// Version registry
const DATA_VERSIONS: Record<number, DataVersion> = {
  1: {
    version: 1,
    dataVersion: "1.0.0",
    schemaChanges: ["Initial schema"],
    migrationRequired: false,
  },
  2: {
    version: 2,
    dataVersion: "1.1.0",
    schemaChanges: ["Added bodyPartHealth tracking", "Added muscleActivation"],
    migrationRequired: true,
  },
};

async function migrateDataVersion(
  item: any,
  fromVersion: number,
  toVersion: number
): Promise<any> {
  let migratedItem = { ...item };
  
  // Apply migrations sequentially
  for (let v = fromVersion + 1; v <= toVersion; v++) {
    migratedItem = await applyMigration(migratedItem, v);
  }
  
  return migratedItem;
}

async function applyMigration(item: any, toVersion: number): Promise<any> {
  switch (toVersion) {
    case 2:
      // Add bodyPartHealth with default values
      return {
        ...item,
        bodyPartHealth: {
          head: item.health * 0.15,
          torso: item.health * 0.40,
          leftArm: item.health * 0.10,
          rightArm: item.health * 0.10,
          leftLeg: item.health * 0.125,
          rightLeg: item.health * 0.125,
        },
        version: 2,
        dataVersion: "1.1.0",
      };
    
    default:
      return item;
  }
}

const tableParams = {
  TableName: "BlackTrigramData",
  SSESpecification: {
    Enabled: true,
    SSEType: "KMS",
    KMSMasterKeyId: "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012",
  },
};

const httpsAgent = new https.Agent({
  minVersion: "TLSv1.3",
  ciphers: "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256",
});

// DynamoDB Stream handler
export const streamHandler = async (event: DynamoDBStreamEvent) => {
  for (const record of event.Records) {
    if (record.eventName === "MODIFY" || record.eventName === "INSERT") {
      await logAuditEvent({
        eventType: record.eventName,
        tableName: record.eventSourceARN.split("/")[1],
        keys: record.dynamodb.Keys,
        userId: record.dynamodb.NewImage.userId.S,
        timestamp: new Date(record.dynamodb.ApproximateCreationDateTime * 1000).toISOString(),
      });
    }
  }
};

// Estimated costs (US East 1)
const costEstimate = {
  storage: {
    perGB: 0.25,  // $0.25 per GB-month
    estimatedGB: 10,
    monthlyCost: 2.50,
  },
  readCapacity: {
    perRCU: 0.00013,  // $0.00013 per RCU-hour
    estimatedRCU: 5,
    monthlyCost: 0.47,
  },
  writeCapacity: {
    perWCU: 0.00065,  // $0.00065 per WCU-hour
    estimatedWCU: 2,
    monthlyCost: 0.94,
  },
  total: 3.91,  // $3.91/month for 1,000 users
};

async function deletePlayerData(userId: string): Promise<void> {
  const items = await queryAllPlayerItems(userId);
  
  // Delete all items in batches
  const batches = chunk(items, 25);  // DynamoDB BatchWriteItem limit
  
  for (const batch of batches) {
    await dynamoDB.batchWriteItem({
      RequestItems: {
        BlackTrigramData: batch.map((item) => ({
          DeleteRequest: {
            Key: {
              PK: item.PK,
              SK: item.SK,
            },
          },
        })),
      },
    });
  }
  
  // Log erasure
  await logAuditEvent({
    eventType: "DATA_DELETION",
    userId,
    timestamp: new Date().toISOString(),
    reason: "GDPR_RIGHT_TO_ERASURE",
  });
}

async function exportPlayerData(userId: string): Promise<PlayerDataExport> {
  const items = await queryAllPlayerItems(userId);
  
  return {
    profile: items.filter((i) => i.SK === "PROFILE")[0],
    gameStates: items.filter((i) => i.SK.startsWith("GAMESTATE#")),
    achievements: items.filter((i) => i.SK.startsWith("ACHIEVEMENT#")),
    purchases: items.filter((i) => i.SK.startsWith("PURCHASE#")),
    exportedAt: new Date().toISOString(),
    format: "JSON",
    version: "1.0.0",
  };
}