TypeScriptのキャスト(as)と型変換：JSONやEnumのパース

// --- 1. as を使ったキャスト（推奨） ---
const someValue: unknown = "Hello TypeScript!";
// 変数を string 型としてキャストして、文字列の length プロパティにアクセスする
const strLength1: number = (someValue as string).length;

// --- 2. <Type> を使ったキャスト（非推奨・TSXでエラーになる） ---
const anotherValue: unknown = "Hello World!";
const strLength2: number = (<string>anotherValue).length;

console.log(strLength1, strLength2); // どちらも正常に動作する

// --- 1. 戻り値の型をキャストする（DOM要素の取得など） ---
// document.getElementById は通常 HTMLElement | null を返す
const inputElement = document.getElementById("user-name");

// もし inputElement が確実に入力フォーム(<input>)だと分かっている場合、
// HTMLInputElement にキャストすることで value プロパティにアクセスできる
if (inputElement) {
  const nameValue = (inputElement as HTMLInputElement).value;
  console.log(`入力された名前: ${nameValue}`);
}

// --- 2. 関数の引数をキャストする ---
interface User {
  id: number;
  name: string;
}

function printUserInfo(user: User) {
  console.log(`[ID: ${user.id}] ${user.name}`);
}

// 外部APIなどから取得した、型が未確定なデータ
const apiResponse: any = { id: 1, name: "Taro Yamada", age: 30 };

// apiResponse には age が含まれているが、引数として渡す際に
// User 型としてキャスト（typescript cast function parameter）することでエラーを回避
printUserInfo(apiResponse as User);

// ❌ 危険な例（型だけを強制し、実態は数値のまま）
const badNum: any = 123;
const badStr = badNum as string; 
// console.log(badStr.toUpperCase()); // 実行時にエラーでクラッシュする！

// ⭕️ 正しい例（実データを文字列に変換する）
const num = 100;
const strFromNum = String(num); // "100"

const bool = true;
const strFromBool = String(bool); // "true"

// undefinedやnullが混入する可能性がある場合の安全な変換
function safeCastToString(value: unknown): string {
  if (value === undefined || value === null) {
    return "";
  }
  // オブジェクトの場合は JSON.stringify を使うと中身が見える
  if (typeof value === "object") {
    return JSON.stringify(value);
  }
  return String(value);
}

console.log(safeCastToString(undefined)); // ""
console.log(safeCastToString({ id: 1 })); // "{"id":1}"

const strPrice = "2980";
const strWithUnit = "150px";
const floatNum = 3.1415;

// --- 基本的な数値への変換 ---
const price1 = Number(strPrice); // 2980
const price2 = +strPrice;        // 2980 (単項プラス演算子を使った簡略記法)

// --- 整数(int)へのパースと小数の切り捨て ---
// 10進数であることを明示するため、第2引数に10を指定するのがベストプラクティス
const parsedInt = parseInt(strWithUnit, 10); // 150

// 小数を整数(int)にキャスト(切り捨て)する場合
const intFromFloat1 = Math.floor(floatNum); // 3 (負の数の挙動に注意)
const intFromFloat2 = Math.trunc(floatNum); // 3 (単純な小数点以下の切り捨て機能)

// --- 安全な変換（NaNのハンドリング） ---
function safeCastToNumber(value: any): number {
  const num = Number(value);
  // 変換結果が NaN だった場合は 0 を返す（あるいはエラーを投げる）
  return Number.isNaN(num) ? 0 : num;
}

console.log(safeCastToNumber("abc")); // NaN になるため 0 が返る

// --- Booleanへのキャスト ---
const someString = "Hello";
const isTruthy1 = Boolean(someString); // true
const isTruthy2 = !!someString;        // true (実務で非常によく使われる記法)

// 🚨 罠：文字列の "false" の扱い
const apiResponseString = "false";
console.log(Boolean(apiResponseString)); // true になってしまう！

// ⭕️ 正しい文字列からBooleanへの変換
function stringToBoolean(str: string): boolean {
  return str.toLowerCase() === "true";
}
console.log(stringToBoolean("false")); // false


// --- Date型へのキャスト ---
const dateStr = "2023-10-01T12:00:00Z";
const badDateStr = "2023-99-99"; // 存在しない日付

// 文字列からDateオブジェクトへの変換
const myDate = new Date(dateStr);

// 🚨 罠：不正な日付のハンドリング
const invalidDate = new Date(badDateStr);
console.log(invalidDate); // "Invalid Date" (エラーは出ない)

// ⭕️ 正しいDateの検証
function safeCastToDate(dateString: string): Date | null {
  const d = new Date(dateString);
  // getTime() が NaN になるかどうかで、有効な日付か判定できる
  if (Number.isNaN(d.getTime())) {
    console.error("無効な日付フォーマットです");
    return null; // またはデフォルトの日付を返す、エラーを投げるなど
  }
  return d;
}

console.log(safeCastToDate(badDateStr)); // null

interface UserProfile {
  id: number;
  username: string;
  isActive: boolean;
}

// 外部から取得したと仮定したJSON文字列
const jsonString = '{"id": 1, "username": "Taro"}'; // 🚨 isActiveが欠けている！

// --- 一般的なキャスト（リスクあり） ---
// typescript cast json to interface
const user = JSON.parse(jsonString) as UserProfile;

// コンパイルは通るが、実行時に undefined になる
console.log(user.isActive); // undefined

// --- 安全なパースとチェックの例 ---
function safeParseUser(jsonStr: string): UserProfile | null {
  try {
    // typescript cast json to object
    const parsed = JSON.parse(jsonStr) as Partial<UserProfile>;
    
    // 実行時に必須プロパティが存在するかチェックする（型ガード）
    if (typeof parsed.id === 'number' && typeof parsed.username === 'string') {
      // 安全が確認できたら、完全な型として扱う
      return parsed as UserProfile;
    }
    console.error("データの形式が不正です");
    return null;
  } catch (e) {
    console.error("JSONのパースに失敗しました");
    return null;
  }
}

console.log(safeParseUser(jsonString)); // エラーとして弾かれる（安全）

interface AnimalData {
  name: string;
  age: number;
}

// クラスの定義（メソッドを持つ）
class Dog {
  name: string;
  age: number;

  constructor(data: AnimalData) {
    this.name = data.name;
    this.age = data.age;
  }

  bark() {
    console.log(`${this.name} says: Bow wow!`);
  }
}

// 外部から取得したプレーンなオブジェクト（typescript cast object to interface）
const rawData: any = { name: "Pochi", age: 3 };
const animalData = rawData as AnimalData; 

// ❌ 危険なキャスト（typescript cast object to class / typescript cast interface to class）
const fakeDog = animalData as Dog;
// fakeDog.bark(); // 🚨 TypeError: fakeDog.bark is not a function （クラッシュ！）

// ⭕️ 正しいクラスのインスタンス化
const realDog = new Dog(animalData);
realDog.bark(); // "Pochi says: Bow wow!" （正常に動作する）

// --- 1. any から配列への安全なキャスト（typescript cast any to array） ---
const unknownData: any = ["Apple", "Banana", "Cherry"];
const notAnArrayData: any = "Just a string";

// ❌ 危険：中身を確認せずにキャストする
// const badArray = notAnArrayData as string[];
// badArray.map(item => console.log(item)); // 🚨 クラッシュ！

// ⭕️ 正しい：Array.isArray で型ガード（型の絞り込み）を行う
if (Array.isArray(unknownData)) {
  // typescript cast to array (このブロック内では unknownData は any[] として扱われる)
  const fruits = unknownData as string[];
  fruits.map(fruit => console.log(`Fruit: ${fruit}`)); // 安全
}

// --- 2. オブジェクトから配列への変換（typescript cast object to array） ---
// キーがID、値がユーザー名になっているようなオブジェクト
const usersObject = {
  "101": "Taro",
  "102": "Jiro",
  "103": "Saburo"
};

// ❌ キャストでは変換できない
// const usersArray = usersObject as unknown as string[]; // 意味がない

// ⭕️ Object.values() や Object.entries() を使って配列を生成する
const usernamesArray: string[] = Object.values(usersObject);
console.log(usernamesArray); // ["Taro", "Jiro", "Saburo"]

const userEntries: [string, string][] = Object.entries(usersObject);
userEntries.forEach(([id, name]) => {
  console.log(`ID: ${id}, Name: ${name}`);
});

// --- 文字列のEnum（String Enum） ---
enum UserRole {
  ADMIN = "admin",
  USER = "user",
  GUEST = "guest",
}

// 外部から来た未定義の文字列
const apiRoleString: string = "admin";
const badRoleString: string = "super_admin";

// ❌ 危険なキャスト（typescript cast string to enum）
// const role1 = badRoleString as UserRole; // コンパイルは通るが、バグの温床になる

// ⭕️ 安全なキャスト（実行時チェックを含む）
function safeCastToRoleEnum(value: string): UserRole | null {
  // Object.values を使って、値がEnum内に存在するかチェックする
  if (Object.values(UserRole).includes(value as UserRole)) {
    return value as UserRole;
  }
  return null;
}

console.log(safeCastToRoleEnum(apiRoleString)); // "admin" (UserRole.ADMIN)
console.log(safeCastToRoleEnum(badRoleString)); // null (安全に弾かれる)


// --- 数値のEnum（Numeric Enum） ---
enum LogLevel {
  INFO = 1,
  WARN = 2,
  ERROR = 3,
}

// 外部から来た数値（typescript cast number to enum / typescript cast int to enum）
const apiStatusCode: number = 2;

// Numeric Enumの場合も同様にバリデーションを行う
function safeCastToLogLevel(value: number): LogLevel | null {
  if (Object.values(LogLevel).includes(value as LogLevel)) {
    return value as LogLevel;
  }
  return null;
}

console.log(safeCastToLogLevel(apiStatusCode)); // 2 (LogLevel.WARN)

// 文字列Enum
enum Status {
  DRAFT = "draft",
  PUBLISHED = "published",
}

// 数値Enum
enum Direction {
  UP = 1,
  DOWN = 2,
}

const currentStatus = Status.PUBLISHED;
const currentDirection = Direction.UP;

// --- 1. 単純なキャスト ---
// Enumを文字列として出力する（typescript cast enum to string）
const statusStr: string = String(currentStatus); // "published"

// Enumを数値として計算などに使う（typescript cast enum to number）
const directionNum: number = currentDirection as number; // 1


// --- 2. 🚨 Numeric Enumのリバースマッピングの罠 ---

// String Enumの keys/values は直感的
console.log(Object.keys(Status));   // ["DRAFT", "PUBLISHED"]
console.log(Object.values(Status)); // ["draft", "published"]

// しかし、Numeric Enumの場合は両方混ざる！
console.log(Object.keys(Direction));   // ["1", "2", "UP", "DOWN"]
console.log(Object.values(Direction)); // ["UP", "DOWN", 1, 2]

// ⭕️ 解決策：数値Enumからキー（文字列）だけ、あるいは数値だけを抽出するヘルパー関数
function getNumericEnumValues(enumObj: any): number[] {
  // typeof が number のものだけを抽出（typescript cast enum to number の応用）
  return Object.values(enumObj).filter(v => typeof v === "number") as number[];
}

function getNumericEnumKeys(enumObj: any): string[] {
  // typeof が string であり、かつ数値にパースできないもの（キー名）だけを抽出
  return Object.keys(enumObj).filter(k => Number.isNaN(Number(k)));
}

console.log(getNumericEnumValues(Direction)); // [1, 2]
console.log(getNumericEnumKeys(Direction));   // ["UP", "DOWN"]

interface UserData {
  name: string;
  age: number;
}

// 外部から取得した型が不明なデータ（anyではなくunknownを使うのがベストプラクティス）
const fetchData = (): unknown => {
  return { name: "Alice", age: 25 };
};

const responseData = fetchData();

// ❌ 危険：チェックせずにキャストする（typescript cast unknown to type）
// const badUser = responseData as UserData;
// console.log(badUser.name.toUpperCase()); // もしデータが数値だったらここでクラッシュする

// ⭕️ 安全：型ガード（ユーザー定義型ガード）を用いて実行時チェックを行う
function isUserData(data: unknown): data is UserData {
  // typescript cast unknown to object として、まずはオブジェクトであることを確認
  if (typeof data !== "object" || data === null) return false;
  
  // プロパティの存在と型を確認
  const obj = data as Record<string, unknown>;
  return typeof obj.name === "string" && typeof obj.age === "number";
}

if (isUserData(responseData)) {
  // このブロック内では responseData は確実に UserData として扱われる（安全なキャスト）
  console.log(`User: ${responseData.name}, Age: ${responseData.age}`);
} else {
  console.error("無効なデータ形式です");
}

interface Admin {
  type: "admin";
  adminLevel: number;
}

interface GeneralUser {
  type: "user";
  nickname: string;
}

type AppUser = Admin | GeneralUser;

function printUserInfo(user: AppUser) {
  // ❌ 悪い例：asを使って無理やりキャストする（typescript cast union type）
  // if ((user as Admin).type === "admin") {
  //   console.log(`管理者レベル: ${(user as Admin).adminLevel}`);
  // }

  // ⭕️ 良い例1：タグ付きUnionによる絞り込み（最も推奨される）
  // TypeScriptは `type` プロパティのチェックだけで、型を安全に絞り込んでくれる
  if (user.type === "admin") {
    // ここでは自動的に Admin 型として扱われる（キャスト不要）
    console.log(`管理者レベル: ${user.adminLevel}`);
  } else {
    // ここでは自動的に GeneralUser 型として扱われる
    console.log(`ユーザー名: ${user.nickname}`);
  }

  // ⭕️ 良い例2：in 演算子を使った絞り込み
  if ("adminLevel" in user) {
    console.log(`管理者レベル: ${user.adminLevel}`);
  }
}

printUserInfo({ type: "admin", adminLevel: 5 });

const someValue = "12345";

// ❌ コンパイルエラー：互換性のない型への直接キャストはTSが弾いてくれる
// const badNum = someValue as number; 

// ⚠️ 危険：二重キャストによる強制キャスト（typescript force type cast）
// unknownを経由することでコンパイラを騙せるが、実行時の実態は "12345" (文字列) のまま
const forcedNum = someValue as unknown as number; 
// console.log(forcedNum.toFixed(2)); // 実行時に TypeError でクラッシュ！


// ⭕️ ベストプラクティス：typescript safe cast（安全な変換関数を用意する）
// typescript conditional cast のように、条件を満たした場合のみ型と値を変換する
function safeCastToNumber(val: unknown): number | null {
  if (typeof val === "number") return val;
  if (typeof val === "string") {
    const parsed = Number(val);
    return Number.isNaN(parsed) ? null : parsed;
  }
  return null;
}

const safeNum = safeCastToNumber(someValue);
if (safeNum !== null) {
  console.log(safeNum.toFixed(2)); // "12345.00"（安全に実行できる）
} else {
  console.error("数値に変換できませんでした");
}