type RecoveryDraftPayload = Record<string, any>
type RecoveryPageId = number | string

const RECOVERY_DOCUMENT_TYPE = 'recovery'
const RECOVERY_CURRENT_CASE_KEY = 'recovery_current_case_id'

const RECOVERY_PAGE_PATH_MAP: Record<string, string> = {
  '1': '/document-writer/recovery',
  '2': '/document-writer/recovery-2',
  '3': '/document-writer/recovery-3',
  '4': '/document-writer/recovery-4',
  '5': '/document-writer/recovery-5',
  '7': '/document-writer/recovery-7',
  '10': '/document-writer/recovery-10',
  '11': '/document-writer/recovery-11',
  '11_1': '/document-writer/recovery-11-1',
  '11_2': '/document-writer/recovery-11-2',
  '11_3': '/document-writer/recovery-11-3',
  '12': '/document-writer/recovery-12',
  '12_1': '/document-writer/recovery-12-1',
  '13': '/document-writer/recovery-13',
  '13_1': '/document-writer/recovery-13-1',
  '14': '/document-writer/recovery-14',
  '15': '/document-writer/recovery-15',
  '15_1': '/document-writer/recovery-15-1',
  '15_2': '/document-writer/recovery-15-2',
  '15_3': '/document-writer/recovery-15-3',
  '15_4': '/document-writer/recovery-15-4',
  '15_5': '/document-writer/recovery-15-5',
  '16': '/document-writer/recovery-16',
  '17': '/document-writer/recovery-17'
}

const normalizePageId = (pageId: RecoveryPageId) => String(pageId)

const readLocalRecoveryPage1Snapshot = () => {
  if (!process.client) return {}

  const storageKeys = ['recovery_page1_draft', 'recovery_page1']
  for (const storageKey of storageKeys) {
    const raw = localStorage.getItem(storageKey)
    if (!raw) continue

    try {
      const parsed = JSON.parse(raw)
      if (parsed && typeof parsed === 'object') {
        return parsed
      }
    } catch {
      continue
    }
  }

  return {}
}

export const useRecoveryDraft = () => {
  const config = useRuntimeConfig()
  const authStore = useAuthStore()
  const route = useRoute()

  const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))

  const getAuthHeaders = () => ({
    Authorization: `Bearer ${authStore.token}`
  })

  const getStoredCurrentCaseId = () => {
    if (!process.client) return null

    const routeCaseId = route.query.caseId
    if (routeCaseId) {
      return Number(routeCaseId)
    }

    const stored = localStorage.getItem(RECOVERY_CURRENT_CASE_KEY)
    return stored ? Number(stored) : null
  }

  const setStoredCurrentCaseId = (caseId: number) => {
    if (!process.client) return
    localStorage.setItem(RECOVERY_CURRENT_CASE_KEY, String(caseId))
  }

  const clearStoredCurrentCaseId = () => {
    if (!process.client) return
    localStorage.removeItem(RECOVERY_CURRENT_CASE_KEY)
  }

  const syncCaseContextFromRoute = () => {
    if (!process.client) return

    if (route.query.mode === 'new') {
      clearStoredCurrentCaseId()
      return
    }

    const routeCaseId = route.query.caseId
    if (routeCaseId) {
      setStoredCurrentCaseId(Number(routeCaseId))
    }
  }

  const getPage1Summary = (pageData?: RecoveryDraftPayload) => {
    const localPage1 = readLocalRecoveryPage1Snapshot()
    const source = pageData && typeof pageData === 'object'
      ? { ...localPage1, ...pageData }
      : localPage1

    const applicantName = String(source.applicantName || source.applicant_name || '').trim()
    const caseNumber = String(source.caseNumber || source.case_number || '').trim()
    const filingDate = String(source.filingDate || source.registrationDate || source.registration_date || '').trim()
    const mobileParts = [
      source.mobilePart1 || source.mobile_part_1,
      source.mobilePart2 || source.mobile_part_2,
      source.mobilePart3 || source.mobile_part_3
    ].filter(Boolean)
    const applicantPhone = mobileParts.length === 3 ? mobileParts.join('-') : ''

    return {
      applicantName: applicantName || '개인회생 임시저장',
      applicantBirthYear: '',
      applicantPhone,
      caseNumber,
      registrationDate: filingDate || new Date().toISOString().split('T')[0]
    }
  }

  const buildDraftTitle = (summary: ReturnType<typeof getPage1Summary>) =>
    `${summary.applicantName || '개인회생'} 개인회생`

  const createRecoveryCaseWithRetry = async (body: Record<string, any>) => {
    const retryDelays = [0, 1200, 2400]
    let lastError: any = null

    for (const delay of retryDelays) {
      if (delay > 0) {
        await wait(delay)
      }

      try {
        return await $fetch<{ success: boolean; caseId: number }>('/cases', {
          method: 'POST',
          baseURL: config.public.apiBase,
          headers: getAuthHeaders(),
          body
        })
      } catch (error: any) {
        lastError = error
        const statusCode = error?.response?.status || error?.statusCode
        if (statusCode !== 429) {
          throw error
        }
      }
    }

    throw lastError
  }

  const getRecoveryDocument = async (caseId: number) => {
    const response = await $fetch<{ success: boolean; documents: any[] }>('/documents', {
      baseURL: config.public.apiBase,
      headers: getAuthHeaders(),
      query: {
        caseId,
        documentType: RECOVERY_DOCUMENT_TYPE,
        limit: 20
      }
    })

    return response.documents?.[0] || null
  }

  const parseDocumentContent = (document: any) => {
    if (!document?.content) return {}

    if (typeof document.content === 'string') {
      try {
        return JSON.parse(document.content)
      } catch {
        return {}
      }
    }

    return document.content
  }

  const ensureRecoveryCase = async (pageData?: RecoveryDraftPayload) => {
    const existingCaseId = getStoredCurrentCaseId()
    if (existingCaseId) {
      return existingCaseId
    }

    const summary = getPage1Summary(pageData)

    const createResponse = await createRecoveryCaseWithRetry({
      caseType: RECOVERY_DOCUMENT_TYPE,
      applicantName: summary.applicantName,
      applicantBirthYear: summary.applicantBirthYear,
      applicantPhone: summary.applicantPhone,
      caseNumber: summary.caseNumber,
      memo: '임시저장',
      registrationDate: summary.registrationDate
    })

    await $fetch(`/cases/${createResponse.caseId}`, {
      method: 'PUT',
      baseURL: config.public.apiBase,
      headers: getAuthHeaders(),
      body: {
        recoveryStatus: 'before_filing',
        memo: '임시저장',
        lastDraftPage: '1'
      }
    })

    setStoredCurrentCaseId(createResponse.caseId)
    return createResponse.caseId
  }

  const saveRecoveryDraftPage = async (pageNumber: RecoveryPageId, pageData: RecoveryDraftPayload) => {
    const pageId = normalizePageId(pageNumber)
    const caseId = await ensureRecoveryCase(pageData)
    const summary = getPage1Summary(pageData)

    const response = await $fetch<{ success: boolean; documentId?: number }>('/documents/page-drafts', {
      method: 'POST',
      baseURL: config.public.apiBase,
      headers: getAuthHeaders(),
      body: {
        caseId,
        documentType: RECOVERY_DOCUMENT_TYPE,
        pageId,
        formData: pageData,
        summary,
        title: buildDraftTitle(summary)
      }
    })

    await $fetch(`/cases/${caseId}`, {
      method: 'PUT',
      baseURL: config.public.apiBase,
      headers: getAuthHeaders(),
      body: {
        applicantName: summary.applicantName,
        applicantPhone: summary.applicantPhone,
        caseNumber: summary.caseNumber,
        recoveryStatus: 'before_filing',
        memo: '임시저장',
        lastDraftPage: pageId,
        documentId: response.documentId
      }
    })

    return caseId
  }

  const loadRecoveryDraftPage = async (pageNumber: RecoveryPageId) => {
    const pageId = normalizePageId(pageNumber)
    const caseId = getStoredCurrentCaseId()
    if (!caseId) return null

    try {
      await $fetch(`/cases/${caseId}`, {
        method: 'PUT',
        baseURL: config.public.apiBase,
        headers: getAuthHeaders(),
        body: {
          lastDraftPage: pageId
        }
      })
    } catch (error) {
      console.error('마지막 페이지 저장 오류:', error)
    }

    const response = await $fetch<{ success: boolean; draft: { pageId: string; formData: RecoveryDraftPayload } | null }>('/documents/page-drafts', {
      baseURL: config.public.apiBase,
      headers: getAuthHeaders(),
      query: {
        caseId,
        documentType: RECOVERY_DOCUMENT_TYPE,
        pageId
      }
    })

    if (response.draft?.formData) {
      return response.draft.formData
    }

    const existingDocument = await getRecoveryDocument(caseId)
    const legacyContent = parseDocumentContent(existingDocument)
    return legacyContent?.pages?.[pageId] || legacyContent?.pages?.[pageNumber] || null
  }

  const loadRecoveryDraftPages = async (caseId: number, pageIds?: RecoveryPageId[]) => {
    const response = await $fetch<{ success: boolean; drafts: Array<{ pageId: string; formData: RecoveryDraftPayload }> }>('/documents/page-drafts', {
      baseURL: config.public.apiBase,
      headers: getAuthHeaders(),
      query: {
        caseId,
        documentType: RECOVERY_DOCUMENT_TYPE,
        pageIds: pageIds?.map(normalizePageId).join(',')
      }
    })

    if (response.drafts?.length) {
      return response.drafts.reduce<Record<string, RecoveryDraftPayload>>((acc, draft) => {
        acc[draft.pageId] = draft.formData
        return acc
      }, {})
    }

    const existingDocument = await getRecoveryDocument(caseId)
    const legacyContent = parseDocumentContent(existingDocument)
    return legacyContent?.pages || {}
  }

  const getRecoveryPagePath = (pageId?: RecoveryPageId | null) =>
    RECOVERY_PAGE_PATH_MAP[normalizePageId(pageId || 1)] || RECOVERY_PAGE_PATH_MAP['1']

  const resolveRecoveryEditPath = async (caseId: number) => {
    const response = await $fetch<{ success: boolean; case: { last_draft_page?: string | null } }>(`/cases/${caseId}`, {
      baseURL: config.public.apiBase,
      headers: getAuthHeaders()
    })

    return `${getRecoveryPagePath(response.case?.last_draft_page || '1')}?caseId=${caseId}`
  }

  return {
    clearStoredCurrentCaseId,
    getRecoveryPagePath,
    getStoredCurrentCaseId,
    loadRecoveryDraftPage,
    loadRecoveryDraftPages,
    resolveRecoveryEditPath,
    saveRecoveryDraftPage,
    syncCaseContextFromRoute
  }
}