import { Game, GameStatusEnum } from 'igdb-types';

import { Game } from 'igdb-types';

// Type checking for game objects
const game: Game = {
  name: "The Witcher 3: Wild Hunt",
  slug: "the-witcher-3-wild-hunt",
  summary: "A story-driven, open world RPG set in a fantasy universe",
  first_release_date: 1431993600, // Unix timestamp
  checksum: "abc123", // UUID hash
  created_at: new Date(),
  updated_at: new Date()
};

// Access properties with full type safety
console.log(game.name); // "The Witcher 3: Wild Hunt"
console.log(game.first_release_date); // 1431993600

import { GameSchema, validate, isGame } from 'igdb-types/validators';

// Validate a game object using the schema and validate function
const gameData = {
  name: "The Witcher 3: Wild Hunt",
  slug: "the-witcher-3-wild-hunt",
  checksum: "abc123",
  created_at: 1431993600,
  updated_at: 1431993600
};

// Method 1: Using the validate utility function
const result = validate(GameSchema, gameData);
if (result.success) {
  // Data is valid and typed as Game
  const validatedGame = result.data;
  console.log(`Validated game: ${validatedGame.name}`);
} else {
  // Data is invalid, error contains validation details
  console.error('Validation failed:', result.error);
}

// Method 2: Using the type guard function
if (isGame(gameData)) {
  // gameData is now typed as Game
  console.log(`Valid game: ${gameData.name}`);
} else {
  console.error('Invalid game object');
}

// Method 3: Direct schema validation
try {
  // Parse will throw an error if validation fails
  const validatedGame = GameSchema.parse(gameData);
  console.log(`Validated game: ${validatedGame.name}`);
} catch (error) {
  console.error('Validation failed:', error);
}

import { Game, GameStatusEnum, GameCategoryEnum } from 'igdb-types';

// Using enums for type-safe categorical data
const releasedGame: Game = {
  name: "Cyberpunk 2077",
  slug: "cyberpunk-2077",
  status: GameStatusEnum.RELEASED, // Using enum value
  category: GameCategoryEnum.MAIN_GAME,
  checksum: "def456",
  created_at: new Date(),
  updated_at: new Date()
};

// Type checking prevents invalid enum values
// This would cause a TypeScript error:
// const invalidGame: Game = {
//   status: "not-a-valid-status", // Error: Type '"not-a-valid-status"' is not assignable to type 'GameStatusEnum'
// };

// Enum values can be used in conditionals
if (releasedGame.status === GameStatusEnum.RELEASED) {
  console.log("Game is released!");
}

import { Game, Platform, Genre } from 'igdb-types';

// Example with ID references (unexpanded)
const basicGame: Game = {
  name: "Halo Infinite",
  platforms: [48, 49, 169], // Xbox One, Xbox Series X|S, PC
  genres: [5, 12], // Shooter, Role-playing (RPG)
  checksum: "ghi789",
  created_at: new Date(),
  updated_at: new Date()
};

// Example with expanded relationships
const expandedGame: Game = {
  name: "Halo Infinite",
  // Full Platform objects instead of just IDs
  platforms: [
    {
      id: 48,
      name: "Xbox One",
      slug: "xbox-one",
      checksum: "platform1",
      created_at: new Date(),
      updated_at: new Date()
    },
    {
      id: 49,
      name: "Xbox Series X|S",
      slug: "xbox-series-x",
      checksum: "platform2",
      created_at: new Date(),
      updated_at: new Date()
    }
  ],
  // Full Genre objects
  genres: [
    {
      id: 5,
      name: "Shooter",
      slug: "shooter",
      checksum: "genre1",
      created_at: new Date(),
      updated_at: new Date()
    }
  ],
  checksum: "ghi789",
  created_at: new Date(),
  updated_at: new Date()
};

// You can access expanded relationship data
if (Array.isArray(expandedGame.platforms)) {
  expandedGame.platforms.forEach(platform => {
    if (typeof platform === 'number') {
      console.log(`Platform ID: ${platform}`);
    } else {
      console.log(`Platform Name: ${platform.name}`);
    }
  });
}

import { Game, AgeRating, AgeRatingCategoryEnum } from 'igdb-types';
import axios from 'axios';

// Example function to fetch games from IGDB API
async function fetchGames(): Promise<Game[]> {
  const response = await axios.post('https://api.igdb.com/v4/games', 
    'fields name,genres.name,platforms.name,age_ratings.*; limit 10;',
    {
      headers: {
        'Client-ID': 'your-client-id',
        'Authorization': 'Bearer your-access-token'
      }
    }
  );

  // Response data is now typed as Game[]
  return response.data as Game[];
}

// Using the typed response
async function displayGameInfo() {
  const games = await fetchGames();

  games.forEach(game => {
    console.log(`Game: ${game.name}`);

    // Type-safe access to age ratings
    if (game.age_ratings) {
      game.age_ratings.forEach(rating => {
        if (typeof rating !== 'number') {
          // This is an expanded AgeRating object
          const ratingObj: AgeRating = rating;

          // Access enum values
          if (ratingObj.category === AgeRatingCategoryEnum.ESRB) {
            console.log('ESRB Rating:', ratingObj.rating);
          }
        }
      });
    }
  });
}