/**
 * PIPE 전용 리비전 관리 훅
 * 
 * Cutting Plan 작성 전/후에 따른 차별화된 리비전 처리
 */

import { useState, useEffect, useCallback } from 'react';
import api from '../api';
import { PipeLogger, PIPE_CONSTANTS } from '../utils/pipeUtils';

export const usePipeRevision = (jobNo, fileId) => {
    const [revisionStatus, setRevisionStatus] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState('');
    const [comparisonResult, setComparisonResult] = useState(null);

    // 리비전 상태 확인
    const checkRevisionStatus = useCallback(async () => {
        if (!jobNo || !fileId) return;

        setLoading(true);
        setError('');

        try {
            PipeLogger.logPipeOperation('리비전 상태 확인', jobNo, { fileId });
            
            const response = await api.post('/pipe-revision/check-status', {
                job_no: jobNo,
                new_file_id: parseInt(fileId)
            });

            setRevisionStatus(response.data);
            
            PipeLogger.logPipeOperation('리비전 상태 확인 완료', jobNo, { 
                revisionType: response.data.revision_type,
                requiresAction: response.data.requires_action 
            });
            
            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || 'PIPE 리비전 상태 확인 실패';
            setError(errorMessage);
            
            PipeLogger.logPipeError('리비전 상태 확인', jobNo, err, { fileId });
            return null;
        } finally {
            setLoading(false);
        }
    }, [jobNo, fileId]);

    // Cutting Plan 작성 전 리비전 처리
    const handlePreCuttingPlanRevision = useCallback(async () => {
        if (!jobNo || !fileId) return null;

        setLoading(true);
        setError('');

        try {
            const response = await api.post('/pipe-revision/handle-pre-cutting-plan', {
                job_no: jobNo,
                new_file_id: parseInt(fileId)
            });

            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || 'Cutting Plan 작성 전 리비전 처리 실패';
            setError(errorMessage);
            console.error('Pre-cutting-plan 리비전 처리 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, [jobNo, fileId]);

    // Cutting Plan 작성 후 리비전 처리
    const handlePostCuttingPlanRevision = useCallback(async () => {
        if (!jobNo || !fileId) return null;

        setLoading(true);
        setError('');

        try {
            const response = await api.post('/pipe-revision/handle-post-cutting-plan', {
                job_no: jobNo,
                new_file_id: parseInt(fileId)
            });

            setComparisonResult(response.data);
            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || 'Cutting Plan 작성 후 리비전 처리 실패';
            setError(errorMessage);
            console.error('Post-cutting-plan 리비전 처리 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, [jobNo, fileId]);

    // 리비전 비교 결과 상세 조회
    const getComparisonDetails = useCallback(async (comparisonId) => {
        setLoading(true);
        setError('');

        try {
            const response = await api.get(`/pipe-revision/comparison/${comparisonId}`);
            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || '리비전 비교 결과 조회 실패';
            setError(errorMessage);
            console.error('리비전 비교 결과 조회 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, []);

    // 리비전 변경사항 적용
    const applyRevisionChanges = useCallback(async (comparisonId) => {
        setLoading(true);
        setError('');

        try {
            const response = await api.post(`/pipe-revision/comparison/${comparisonId}/apply`);
            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || '리비전 변경사항 적용 실패';
            setError(errorMessage);
            console.error('리비전 변경사항 적용 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, []);

    // 구매 영향 분석
    const getPurchaseImpact = useCallback(async (comparisonId) => {
        setLoading(true);
        setError('');

        try {
            const response = await api.get(`/pipe-revision/comparison/${comparisonId}/purchase-impact`);
            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || '구매 영향 분석 실패';
            setError(errorMessage);
            console.error('구매 영향 분석 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, []);

    // 리비전 이력 조회
    const getRevisionHistory = useCallback(async () => {
        if (!jobNo) return null;

        setLoading(true);
        setError('');

        try {
            const response = await api.get(`/pipe-revision/job/${jobNo}/history`);
            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || '리비전 이력 조회 실패';
            setError(errorMessage);
            console.error('리비전 이력 조회 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, [jobNo]);

    // 자동 리비전 처리 (상태에 따라 적절한 처리 수행)
    const processRevisionAutomatically = useCallback(async () => {
        try {
            // 1. 리비전 상태 확인
            const status = await checkRevisionStatus();
            if (!status || !status.requires_action) {
                return {
                    success: true,
                    type: 'no_action_needed',
                    message: status?.message || '리비전 처리가 필요하지 않습니다.'
                };
            }

            // 2. 리비전 타입에 따른 처리
            if (status.revision_type === 'pre_cutting_plan') {
                const result = await handlePreCuttingPlanRevision();
                return {
                    success: result !== null,
                    type: 'pre_cutting_plan',
                    data: result,
                    message: result?.message || 'Cutting Plan 작성 전 리비전 처리 완료'
                };
            } else if (status.revision_type === 'post_cutting_plan') {
                const result = await handlePostCuttingPlanRevision();
                return {
                    success: result !== null,
                    type: 'post_cutting_plan',
                    data: result,
                    message: result?.message || 'Cutting Plan 작성 후 리비전 처리 완료'
                };
            }

            return {
                success: false,
                type: 'unknown',
                message: '알 수 없는 리비전 타입입니다.'
            };

        } catch (err) {
            console.error('자동 리비전 처리 실패:', err);
            return {
                success: false,
                type: 'error',
                message: '자동 리비전 처리 중 오류가 발생했습니다.'
            };
        }
    }, [checkRevisionStatus, handlePreCuttingPlanRevision, handlePostCuttingPlanRevision]);

    // 컴포넌트 마운트 시 리비전 상태 확인
    useEffect(() => {
        if (jobNo && fileId) {
            checkRevisionStatus();
        }
    }, [jobNo, fileId, checkRevisionStatus]);

    return {
        // 상태
        revisionStatus,
        comparisonResult,
        loading,
        error,

        // 액션
        checkRevisionStatus,
        handlePreCuttingPlanRevision,
        handlePostCuttingPlanRevision,
        getComparisonDetails,
        applyRevisionChanges,
        getPurchaseImpact,
        getRevisionHistory,
        processRevisionAutomatically,

    // Cutting Plan 확정 (스냅샷 생성)
    finalizeCuttingPlan: useCallback(async () => {
        if (!jobNo) return null;

        setLoading(true);
        setError('');

        try {
            const response = await api.post('/pipe-snapshot/finalize-cutting-plan', {
                job_no: jobNo,
                created_by: 'user'  // 추후 실제 사용자 정보로 변경
            });

            return response.data;
        } catch (err) {
            const errorMessage = err.response?.data?.detail || 'Cutting Plan 확정 실패';
            setError(errorMessage);
            console.error('Cutting Plan 확정 실패:', err);
            return null;
        } finally {
            setLoading(false);
        }
    }, [jobNo]),

    // 스냅샷 상태 확인
    getSnapshotStatus: useCallback(async () => {
        if (!jobNo) return null;

        try {
            const response = await api.get(`/pipe-snapshot/status/${jobNo}`);
            return response.data;
        } catch (err) {
            console.error('스냅샷 상태 확인 실패:', err);
            return null;
        }
    }, [jobNo]),

    // 스냅샷 단관 정보 조회
    getSnapshotSegments: useCallback(async (snapshotId, area = null, drawingName = null) => {
        try {
            const params = new URLSearchParams();
            if (area) params.append('area', area);
            if (drawingName) params.append('drawing_name', drawingName);
            
            const response = await api.get(`/pipe-snapshot/segments/${snapshotId}?${params}`);
            return response.data;
        } catch (err) {
            console.error('스냅샷 단관 조회 실패:', err);
            return null;
        }
    }, []),

    // 사용 가능한 구역 목록 조회
    getAvailableAreas: useCallback(async (snapshotId) => {
        try {
            const response = await api.get(`/pipe-snapshot/areas/${snapshotId}`);
            return response.data;
        } catch (err) {
            console.error('구역 목록 조회 실패:', err);
            return null;
        }
    }, []),

    // 사용 가능한 도면 목록 조회
    getAvailableDrawings: useCallback(async (snapshotId, area = null) => {
        try {
            const params = area ? `?area=${encodeURIComponent(area)}` : '';
            const response = await api.get(`/pipe-snapshot/drawings/${snapshotId}${params}`);
            return response.data;
        } catch (err) {
            console.error('도면 목록 조회 실패:', err);
            return null;
        }
    }, []),

    // 리비전 보호 상태 확인
    checkRevisionProtection: useCallback(async () => {
        if (!jobNo) return null;

        try {
            const response = await api.get(`/pipe-snapshot/revision-protection/${jobNo}`);
            return response.data;
        } catch (err) {
            console.error('리비전 보호 상태 확인 실패:', err);
            return null;
        }
    }, [jobNo]),

    // 확정된 Excel 내보내기
    exportFinalizedExcel: useCallback(async () => {
        if (!jobNo) return null;

        try {
            const response = await api.get(`/pipe-excel/export-finalized/${jobNo}`, {
                responseType: 'blob'
            });

            // 파일 다운로드
            const blob = new Blob([response.data], { 
                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' 
            });
            const url = window.URL.createObjectURL(blob);
            const link = document.createElement('a');
            link.href = url;
            link.download = `PIPE_Cutting_Plan_${jobNo}_FINALIZED.xlsx`;
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
            window.URL.revokeObjectURL(url);

            return { success: true, message: 'Excel 파일이 다운로드되었습니다.' };
        } catch (err) {
            const errorMessage = err.response?.data?.detail || '확정된 Excel 내보내기 실패';
            setError(errorMessage);
            console.error('확정된 Excel 내보내기 실패:', err);
            return { success: false, message: errorMessage };
        }
    }, [jobNo]),

    // 확정 상태 확인
    checkFinalizationStatus: useCallback(async () => {
        if (!jobNo) return null;

        try {
            const response = await api.get(`/pipe-excel/check-finalization/${jobNo}`);
            return response.data;
        } catch (err) {
            console.error('확정 상태 확인 실패:', err);
            return null;
        }
    }, [jobNo]),

    // 유틸리티
    clearError: () => setError(''),
    isPreCuttingPlan: revisionStatus?.revision_type === 'pre_cutting_plan',
    isPostCuttingPlan: revisionStatus?.revision_type === 'post_cutting_plan',
    requiresAction: revisionStatus?.requires_action || false
    };
};

export default usePipeRevision;
