// これが判別可能ユニオン！
type Order = 
  | { status: 'pending'; paymentDeadline: Date }    // statusが'pending'なら、paymentDeadlineがある
  | { status: 'shipped'; trackingNumber: string }   // statusが'shipped'なら、trackingNumberがある
  | { status: 'delivered'; deliveryDate: Date }     // statusが'delivered'なら、deliveryDateがある

// 支払い待ち、処理中、発送済み、配達完了、キャンセル済み、返金済み...

interface Order {
  status: 'pending' | 'processing' | 'shipped' | 'delivered' | 'cancelled' | 'refunded'
  paymentDeadline?: Date
  trackingNumber?: string
  deliveryDate?: Date
  refundAmount?: number
  refundReason?: string
  cancelReason?: string
}

function processOrder(order: Order) {
  if (order.status === 'shipped') {
    if (!order.trackingNumber) {
      throw new Error('追跡番号がないのに発送済み？？')
    }
    sendTrackingEmail(order.trackingNumber)
  }
}

type Order = 
  | { status: 'pending'; orderId: string; amount: number; paymentDeadline: Date }
  | { status: 'processing'; orderId: string; amount: number; estimatedShipDate: Date }
  | { status: 'shipped'; orderId: string; amount: number; trackingNumber: string; carrier: string }
  | { status: 'delivered'; orderId: string; amount: number; deliveryDate: Date; signedBy: string }
  | { status: 'cancelled'; orderId: string; amount: number; cancelReason: string; cancelledAt: Date }
  | { status: 'refunded'; orderId: string; amount: number; refundAmount: number; refundReason: string }

function processOrder(order: Order) {
  switch (order.status) {
    case 'shipped':
      console.log(`発送通知を送信: ${order.trackingNumber}`)
      return sendTrackingEmail(order.trackingNumber, order.carrier)
      
    case 'pending':
      if (order.paymentDeadline < new Date()) {
        return cancelExpiredOrder(order.orderId)
      }
      return sendPaymentReminder(order.orderId, order.paymentDeadline)
      
    default:
      const _exhaustive: never = order
      throw new Error(`未対応の注文ステータス`)
  }
}

type OrderUpdate = 
  | { action: 'order_created'; orderId: string; timestamp: string }
  | { action: 'payment_received'; orderId: string; amount: number }
  | { action: 'order_shipped'; orderId: string; trackingNumber: string }

import { z } from 'zod'

const orderUpdateSchema = z.discriminatedUnion('action', [
  z.object({ 
    action: z.literal('order_created'),
    orderId: z.string(), 
    timestamp: z.string() 
  }),
  z.object({ 
    action: z.literal('payment_received'), 
    orderId: z.string(), 
    amount: z.number() 
  }),
  // ...
])

type OrderUpdate = z.infer<typeof orderUpdateSchema>

const processOrderUpdate = (data: any) => {
  switch (data.action) {
    case 'order_created':
      return `注文 ${data.orderId.toUpperCase()} を作成しました`
    case 'payment_received':
      return `${data.amount * 1.1}円（税込）の支払いを受領しました`
    case 'order_shipped':
      return `追跡番号: ${data.trackingNumber}`
  }
}

import { z } from 'zod'

export const orderHistorySchema = z.discriminatedUnion('action', [
  z.object({
    action: z.literal('order_created'),
    orderId: z.string().regex(/^ORD-[A-Z0-9]+$/),
    timestamp: z.string().datetime(),
  }),
  z.object({
    action: z.literal('payment_received'),
    orderId: z.string(),
    amount: z.number().positive(),
    paymentMethod: z.enum(['credit_card', 'bank_transfer', 'cash_on_delivery']),
  }),
  z.object({
    action: z.literal('order_shipped'),
    orderId: z.string(),
    trackingNumber: z.string().min(1),
    carrier: z.enum(['yamato', 'sagawa', 'japan_post']),
  }),
  z.object({
    action: z.literal('order_delivered'),
    orderId: z.string(),
    deliveredAt: z.string().datetime(),
    receivedBy: z.string().optional(),
  }),
])

// スキーマから型を推論
export type OrderHistory = z.infer<typeof orderHistorySchema>

const processOrderUpdateSafe = (data: unknown) => {
  try {
    // ここがポイント！parse()で実行時検証を行う
    const validated = orderHistorySchema.parse(data)
    
    // ここから先は TypeScript の型システムが働く
    // validated は正しい OrderHistory 型であることが保証されている
    switch (validated.action) {
      case 'order_created':
        return `注文 ${validated.orderId} を作成しました`
      case 'payment_received':
        return `${(validated.amount * 1.1).toFixed(0)}円（税込）の支払いを受領しました`
      case 'order_shipped':
        // ここでは validated.trackingNumber の存在チェックは不要！
        // なぜなら、parse() で検証済みだから
        return `${validated.carrier}で発送しました。追跡番号: ${validated.trackingNumber}`
      case 'order_delivered':
        const receiver = validated.receivedBy || 'ご本人'
        return `${receiver}が受け取りました`
    }
  } catch (error) {
    if (error instanceof z.ZodError) {
      // どのフィールドでエラーが起きたか具体的に取得
      const fieldErrors = error.flatten().fieldErrors
      // 例: { orderId: ["String must match pattern"], amount: ["Number must be positive"] }
      
      console.error('Validation failed:', fieldErrors)
      
      // UIに渡せる形式でエラー情報を返す
      return {
        success: false,
        message: 'データ形式エラー',
        errors: fieldErrors  // 各フィールドのエラーメッセージ
      }
    }
    throw error
  }
}

// ❌ ダメな例
type Notification = 
  | { channel: 'email'; priority: 'high'; to: string; subject: string }
  | { channel: 'sms'; priority: 'urgent'; to: string; message: string }
  | { channel: 'push'; priority: 'high'; to: string; title: string }

function sendNotification(notification: Notification) {
  if (notification.channel === 'email') {
    console.log(notification.subject) // エラー！
  }
}

function explainTypeNarrowing(notification: Notification) {
  if (notification.channel === 'email') {
    console.log(notification.subject) // エラー！
  }
  
  if (notification.channel === 'email' && notification.priority === 'high') {
    console.log(notification.subject) // OK
  }
}

// ✅ 良い例
type Notification = 
  | { type: 'email_high'; to: string; subject: string; body: string }
  | { type: 'email_normal'; to: string; subject: string; body: string }
  | { type: 'sms_urgent'; to: string; message: string }
  | { type: 'push_high'; to: string; title: string; body: string }

function sendNotificationBetter(notification: Notification) {
  switch (notification.type) {
    case 'email_high':
      sendHighPriorityEmail(notification.to, notification.subject)
      break
    case 'sms_urgent':
      sendUrgentSMS(notification.to, notification.message)
      break
  }
}

// ❌ ダメな例
const createOrder = (type: string, status: string) => {
  const orderType = `${type}_${status}`  // これは string 型になっちゃう！
  return { 
    type: orderType,
    orderId: generateId(),
  }
}

const literal = 'pending'              // 型: 'pending' 
let variable = 'pending'               // 型: string
const combined = `${type}_${status}`   // 型: string

// 型レベル（コンパイル時）
type Combined = `${OrderType}_${StatusType}`  

// 値レベル（実行時）
const makeType = (order: string, status: string) => `${order}_${status}`
// 返り値は常にstring型

// ✅ 良い例
type OrderType = 'online_pending' | 'online_confirmed' | 'store_pending' | 'store_ready'

const createOrder = (type: OrderType): Order => {
  switch (type) {
    case 'online_pending':
      return { 
        type,
        orderId: generateId(),
        paymentDeadline: addHours(new Date(), 24)
      }
    case 'store_ready':
      return {
        type,
        orderId: generateId(),
        pickupCode: generatePickupCode()
      }
    // ...
  }
}

// ❌ ダメな例：新しいステータスを追加しても気づけない
function getOrderIcon(order: Order): string {
  switch (order.status) {
    case 'pending': return '⏳'
    case 'shipped': return '📦'
    case 'delivered': return '✅'
    default: return '❓'  // 新しいステータスが全部ここに...
  }
}

function processOrder(order: Order) {
  switch (order.status) {
    case 'pending': return 'A'
    case 'shipped': return 'B'
    case 'delivered': return 'C'
    default:
      const _exhaustive: never = order
      throw new Error('Unreachable')
  }
}

// cancelledを追加したが、処理を忘れた場合
type OrderV2 = Order | { status: 'cancelled' }

// エラー: Type '{ status: "cancelled" }' is not assignable to type 'never'

// ✅ サーバーサイドロジックの例：継続不能なエラーとして扱う
function processOrderCritical(order: Order): string {
  switch (order.status) {
    case 'pending': return 'Processing payment...'
    case 'shipped': return 'Updating inventory...'
    case 'delivered': return 'Closing transaction...'
    case 'cancelled': return 'Reverting changes...'
    case 'refunded': return 'Processing refund...'
    case 'processing': return 'Validating order...'
    default: {
      const _exhaustive: never = order
      throw new Error(`Unknown order status: ${(order as any).status}`)
    }
  }
}

// UIコンポーネントでの例：フォールバックを返す
function getOrderIcon(order: Order): string {
  switch (order.status) {
    case 'pending': return '⏳'
    case 'shipped': return '📦'
    case 'delivered': return '✅'
    default: {
      // 開発環境では警告を出す
      if (process.env.NODE_ENV === 'development') {
        console.warn(`Missing icon for status: ${(order as any).status}`)
      }
      return '📋' // デフォルトアイコンを返す
    }
  }
}