hooks/use-progress-manager.tsx

import type { ProcessingStep } from '@/types/processing';
import { useCallback, useEffect, useState } from 'react';

const DEFAULT_STEPS: ProcessingStep[] = [
  {
    id: 'preprocessing',
    title: '画像前処理',
    description: '画像の前処理を実行しています',
    status: 'pending',
    estimatedTime: 10,
  },
  {
    id: 'segmentation',
    title: '要素識別',
    description: 'AI分析により画像の各要素を識別しています',
    status: 'pending',
    estimatedTime: 30,
  },
  {
    id: 'mask-generation',
    title: 'マスク生成',
    description: '編集用のマスクを生成しています',
    status: 'pending',
    estimatedTime: 20,
  },
  {
    id: 'background',
    title: '背景補完',
    description: '不要な要素を除去し、背景を自然に補完しています',
    status: 'pending',
    estimatedTime: 45,
  },
  {
    id: 'object',
    title: 'オブジェクト再生成',
    description: '人物や商品を著作権フリーの画像に置き換えています',
    status: 'pending',
    estimatedTime: 60,
  },
  {
    id: 'maincopy',
    title: 'メインコピー変更',
    description: '新しいメインコピーテキストを描画しています',
    status: 'pending',
    estimatedTime: 40,
  },
  {
    id: 'header',
    title: 'ヘッダー合成',
    description: '元のヘッダーを保護しながら最終画像を合成しています',
    status: 'pending',
    estimatedTime: 20,
  },
];

interface UseProgressManagerOptions {
  initialSteps?: ProcessingStep[];
  autoProgress?: boolean;
  progressInterval?: number;
}

export function useProgressManager({ initialSteps = DEFAULT_STEPS, autoProgress = false, progressInterval = 1000 }: UseProgressManagerOptions = {}) {
  const [steps, setSteps] = useState<ProcessingStep[]>(initialSteps);
  const [currentStepId, setCurrentStepId] = useState<string | undefined>();
  const [totalProgress, setTotalProgress] = useState(0);
  const [estimatedTimeRemaining, setEstimatedTimeRemaining] = useState<number | undefined>();
  const [isProcessing, setIsProcessing] = useState(false);
  const [startTime, setStartTime] = useState<number | undefined>();

  // ステップを開始する
  const startStep = useCallback(
    (stepId: string) => {
      setSteps((prev) => prev.map((step) => (step.id === stepId ? { ...step, status: 'in_progress' as const } : step)));
      setCurrentStepId(stepId);

      if (!startTime) {
        setStartTime(Date.now());
      }
    },
    [startTime],
  );

  // ステップを完了する
  const completeStep = useCallback(
    (stepId: string, actualTime?: number) => {
      setSteps((prev) =>
        prev.map((step) =>
          step.id === stepId
            ? {
                ...step,
                status: 'completed' as const,
                actualTime: actualTime || step.estimatedTime,
              }
            : step,
        ),
      );

      // 次のステップを自動的に開始
      const currentIndex = steps.findIndex((step) => step.id === stepId);
      if (currentIndex >= 0 && currentIndex < steps.length - 1) {
        const nextStep = steps[currentIndex + 1];
        if (autoProgress) {
          setTimeout(() => startStep(nextStep.id), 500);
        }
      } else {
        // 最後のステップが完了
        setCurrentStepId(undefined);
        setIsProcessing(false);
      }
    },
    [steps, autoProgress, startStep],
  );

  // ステップをエラーにする
  const errorStep = useCallback((stepId: string, errorMessage?: string) => {
    setSteps((prev) =>
      prev.map((step) =>
        step.id === stepId
          ? {
              ...step,
              status: 'error' as const,
              description: errorMessage || step.description,
            }
          : step,
      ),
    );
  }, []);

  // 全体の進行状況を計算
  useEffect(() => {
    const completedSteps = steps.filter((step) => step.status === 'completed').length;
    const currentStepIndex = currentStepId ? steps.findIndex((step) => step.id === currentStepId) : -1;

    let progress = (completedSteps / steps.length) * 100;

    // 現在実行中のステップの進行状況を推定
    if (currentStepIndex >= 0) {
      const partialProgress = (1 / steps.length) * 0.5; // 現在のステップの50%として仮定
      progress += partialProgress * 100;
    }

    setTotalProgress(Math.min(progress, 100));
  }, [steps, currentStepId]);

  // 残り時間を計算
  useEffect(() => {
    if (!isProcessing || !currentStepId) {
      setEstimatedTimeRemaining(undefined);
      return;
    }

    const completedSteps = steps.filter((step) => step.status === 'completed');
    const remainingSteps = steps.filter((step) => step.status === 'pending' || (step.status === 'in_progress' && step.id !== currentStepId));
    const currentStep = steps.find((step) => step.id === currentStepId);

    let remainingTime = 0;

    // 残りのステップの推定時間を合計
    remainingSteps.forEach((step) => {
      remainingTime += step.estimatedTime || 30;
    });

    // 現在のステップの残り時間（仮に50%完了と仮定）
    if (currentStep) {
      remainingTime += (currentStep.estimatedTime || 30) * 0.5;
    }

    setEstimatedTimeRemaining(Math.ceil(remainingTime));
  }, [steps, currentStepId, isProcessing]);

  // 処理を開始する
  const startProcessing = useCallback(() => {
    setIsProcessing(true);
    setStartTime(Date.now());
    if (steps.length > 0) {
      startStep(steps[0].id);
    }
  }, [steps, startStep]);

  // 処理をリセットする
  const resetProgress = useCallback(() => {
    setSteps(initialSteps);
    setCurrentStepId(undefined);
    setTotalProgress(0);
    setEstimatedTimeRemaining(undefined);
    setIsProcessing(false);
    setStartTime(undefined);
  }, [initialSteps]);

  // カスタムステップを設定する
  const setCustomSteps = useCallback((newSteps: ProcessingStep[]) => {
    setSteps(newSteps);
    setCurrentStepId(undefined);
    setTotalProgress(0);
  }, []);

  return {
    steps,
    currentStepId,
    totalProgress,
    estimatedTimeRemaining,
    isProcessing,
    startStep,
    completeStep,
    errorStep,
    startProcessing,
    resetProgress,
    setCustomSteps,
  };
}