'use client'

import * as React from 'react'
import { Calendar, Save, RefreshCw, Clock, Send } from 'lucide-react'
import { updateBiddingSchedule, getBiddingById, getSpecificationMeetingDetailsAction } from '@/lib/bidding/service'
import { useSession } from 'next-auth/react'
import { useRouter } from 'next/navigation'

import { Button } from '@/components/ui/button'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
import { Label } from '@/components/ui/label'
import { Textarea } from '@/components/ui/textarea'
import { Switch } from '@/components/ui/switch'
import { ApprovalPreviewDialog } from '@/lib/approval/approval-preview-dialog'
import { requestBiddingInvitationWithApproval } from '@/lib/bidding/approval-actions'
import { prepareBiddingApprovalData } from '@/lib/bidding/approval-actions'
import { BiddingInvitationDialog } from '@/lib/bidding/detail/table/bidding-invitation-dialog'
import { sendBiddingBasicContracts, getSelectedVendorsForBidding, getPrItemsForBidding } from '@/lib/bidding/pre-quote/service'
import { registerBidding } from '@/lib/bidding/detail/service'
import { useToast } from '@/hooks/use-toast'
import { format } from 'date-fns'
interface BiddingSchedule {
  submissionStartOffset?: number      // 시작일 오프셋 (결재 후 n일)
  submissionStartTime?: string        // 시작 시간 (HH:MM)
  submissionDurationDays?: number     // 기간 (시작일 + n일)
  submissionEndTime?: string          // 마감 시간 (HH:MM)
  remarks?: string
  isUrgent?: boolean
  hasSpecificationMeeting?: boolean
}

interface SpecificationMeetingInfo {
  meetingDate: string
  meetingTime: string
  location: string
  address: string
  contactPerson: string
  contactPhone: string
  contactEmail: string
  agenda: string
  materials: string
  notes: string
  isRequired: boolean
}

interface BiddingScheduleEditorProps {
  biddingId: number
  readonly?: boolean
}

interface VendorContractRequirement {
  vendorId: number
  vendorName: string
  vendorCode?: string
  vendorCountry?: string
  vendorEmail?: string
  contactPerson?: string
  contactEmail?: string
  ndaYn?: boolean
  generalGtcYn?: boolean
  projectGtcYn?: boolean
  agreementYn?: boolean
  biddingCompanyId: number
  biddingId: number
  isPreQuoteSelected?: boolean
  contacts?: Array<{
    id: number
    contactName: string
    contactEmail: string
    contactNumber?: string | null
  }>
}

interface VendorWithContactInfo extends VendorContractRequirement {
  contacts: Array<{
    id: number
    contactName: string
    contactEmail: string
    contactPhone?: string | null
    contactPosition?: string | null
    contactDepartment?: string | null
  }>
  selectedMainEmail: string
  additionalEmails: string[]
  customEmails: Array<{
    id: string
    email: string
    name?: string
  }>
  hasExistingContracts: boolean
}

interface BiddingInvitationData {
  vendors: VendorWithContactInfo[]
  generatedPdfs: Array<{
    key: string
    buffer: number[]
    fileName: string
  }>
  message?: string
}

export function BiddingScheduleEditor({ biddingId, readonly = false }: BiddingScheduleEditorProps) {
  const { data: session } = useSession()
  const router = useRouter()
  const { toast } = useToast()
  const [schedule, setSchedule] = React.useState<BiddingSchedule>({})
  const [specMeetingInfo, setSpecMeetingInfo] = React.useState<SpecificationMeetingInfo>({
    meetingDate: '',
    meetingTime: '',
    location: '',
    address: '',
    contactPerson: '',
    contactPhone: '',
    contactEmail: '',
    agenda: '',
    materials: '',
    notes: '',
    isRequired: false,
  })
  const [isLoading, setIsLoading] = React.useState(false)
  const [isSubmitting, setIsSubmitting] = React.useState(false)
  const [biddingInfo, setBiddingInfo] = React.useState<{ title: string; projectName?: string; status: string; biddingNumber?: string } | null>(null)
  const [isBiddingInvitationDialogOpen, setIsBiddingInvitationDialogOpen] = React.useState(false)
  const [isApprovalDialogOpen, setIsApprovalDialogOpen] = React.useState(false)
  const [selectedVendors, setSelectedVendors] = React.useState<VendorContractRequirement[]>([])
  const [approvalVariables, setApprovalVariables] = React.useState<Record<string, string>>({})
  const [approvalTitle, setApprovalTitle] = React.useState('')
  const [invitationData, setInvitationData] = React.useState<BiddingInvitationData | null>(null)

  // 차수 추출 헬퍼 함수
  const getRoundNumber = (biddingNumber: string): number => {
    const match = biddingNumber.match(/-(\d+)$/)
    return match ? parseInt(match[1]) : 1
  }

  // 차수 증가된 입찰인지 확인 (01이 아닌 경우)
  const isRoundIncreased = (biddingNumber?: string): boolean => {
    if (!biddingNumber) return false
    const round = getRoundNumber(biddingNumber)
    return round > 1
  }

  // UTC 날짜를 한국 시간(KST) 기준 datetime-local 입력값으로 변환
  const toKstInputValue = (date: string | Date | undefined | null) => {
    if (!date) return ''
    const d = new Date(date)
    // UTC 시간에 9시간을 더함
    const kstTime = d.getTime() + (9 * 60 * 60 * 1000)
    return new Date(kstTime).toISOString().slice(0, 16)
  }

  // timestamp에서 시간(HH:MM) 추출 (KST 기준)
  const extractTimeFromTimestamp = (date: string | Date | undefined | null): string => {
    if (!date) return ''
    const d = new Date(date)
    // UTC 시간에 9시간을 더함
    const kstTime = d.getTime() + (9 * 60 * 60 * 1000)
    const kstDate = new Date(kstTime)
    const hours = kstDate.getUTCHours().toString().padStart(2, '0')
    const minutes = kstDate.getUTCMinutes().toString().padStart(2, '0')
    return `${hours}:${minutes}`
  }

  // 예상 일정 계산 (오늘 기준 미리보기)
  const getPreviewDates = () => {
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    
    const startOffset = schedule.submissionStartOffset ?? 0
    const durationDays = schedule.submissionDurationDays ?? 7
    const startTime = schedule.submissionStartTime || '09:00'
    const endTime = schedule.submissionEndTime || '18:00'

    // 시작일 계산
    const startDate = new Date(today)
    startDate.setDate(startDate.getDate() + startOffset)
    const [startHour, startMinute] = startTime.split(':').map(Number)
    startDate.setHours(startHour, startMinute, 0, 0)

    // 마감일 계산
    const endDate = new Date(startDate)
    endDate.setHours(0, 0, 0, 0) // 시작일의 날짜만
    endDate.setDate(endDate.getDate() + durationDays)
    const [endHour, endMinute] = endTime.split(':').map(Number)
    endDate.setHours(endHour, endMinute, 0, 0)

    return { startDate, endDate }
  }

  // 데이터 로딩
  React.useEffect(() => {
    const loadSchedule = async () => {
      setIsLoading(true)
      try {
        const bidding = await getBiddingById(biddingId)
        if (bidding) {
          // 입찰 정보 저장
          setBiddingInfo({
            title: bidding.title || '',
            projectName: bidding.projectName || undefined,
            status: bidding.status || '',
            biddingNumber: bidding.biddingNumber || undefined,
          })

          setSchedule({
            submissionStartOffset: bidding.submissionStartOffset ?? 1,
            submissionStartTime: extractTimeFromTimestamp(bidding.submissionStartDate) || '09:00',
            submissionDurationDays: bidding.submissionDurationDays ?? 7,
            submissionEndTime: extractTimeFromTimestamp(bidding.submissionEndDate) || '18:00',
            remarks: bidding.remarks || '',
            isUrgent: bidding.isUrgent || false,
            hasSpecificationMeeting: bidding.hasSpecificationMeeting || false,
          })

          // 사양설명회 정보 로드 (T/F 무관하게 기존 데이터가 있으면 로드)
          try {
            const meetingDetails = await getSpecificationMeetingDetailsAction(biddingId)
            if (meetingDetails.success && meetingDetails.data) {
              const meeting = meetingDetails.data
              setSpecMeetingInfo({
                meetingDate: toKstInputValue(meeting.meetingDate),
                meetingTime: meeting.meetingTime || '',
                location: meeting.location || '',
                address: meeting.address || '',
                contactPerson: meeting.contactPerson || '',
                contactPhone: meeting.contactPhone || '',
                contactEmail: meeting.contactEmail || '',
                agenda: meeting.agenda || '',
                materials: meeting.materials || '',
                notes: meeting.notes || '',
                isRequired: meeting.isRequired || false,
              })
            }
          } catch (error) {
            console.error('Failed to load specification meeting details:', error)
          }
        }
      } catch (error) {
        console.error('Failed to load schedule:', error)
        toast({
          title: '오류',
          description: '일정 정보를 불러오는데 실패했습니다.',
          variant: 'destructive',
        })
      } finally {
        setIsLoading(false)
      }
    }

    loadSchedule()
  }, [biddingId, toast])

  // 선정된 업체들 조회
  const getSelectedVendors = React.useCallback(async (): Promise<VendorContractRequirement[]> => {
    try {
      const result = await getSelectedVendorsForBidding(biddingId)
      if (result.success) {
        // 타입 변환: null을 undefined로 변환
        return result.vendors.map((vendor): VendorContractRequirement => ({
          vendorId: vendor.vendorId,
          vendorName: vendor.vendorName,
          vendorCode: vendor.vendorCode || undefined,
          vendorCountry: vendor.vendorCountry,
          vendorEmail: vendor.vendorEmail || undefined,
          contactPerson: vendor.contactPerson || undefined,
          contactEmail: vendor.contactEmail || undefined,
          ndaYn: vendor.ndaYn,
          generalGtcYn: vendor.generalGtcYn,
          projectGtcYn: vendor.projectGtcYn,
          agreementYn: vendor.agreementYn,
          biddingCompanyId: vendor.biddingCompanyId,
          biddingId: vendor.biddingId,
          isPreQuoteSelected: vendor.isPreQuoteSelected,
          contacts: vendor.contacts || [],
        }))
      } else {
        console.error('선정된 업체 조회 실패:', 'error' in result ? result.error : '알 수 없는 오류')
        return []
      }
    } catch (error) {
      console.error('선정된 업체 조회 실패:', error)
      return []
    }
  }, [biddingId])

  // 입찰 초대 다이얼로그가 열릴 때 선정된 업체들 조회
  React.useEffect(() => {
    if (isBiddingInvitationDialogOpen) {
      getSelectedVendors().then(vendors => {
        setSelectedVendors(vendors)
      })
    }
  }, [isBiddingInvitationDialogOpen, getSelectedVendors])

  // 입찰공고 버튼 클릭 핸들러 - 입찰 초대 다이얼로그 열기
  const handleBiddingInvitationClick = async () => {
    try {
      // 1. 입찰서 제출기간 검증
      if (schedule.submissionStartOffset === undefined || schedule.submissionDurationDays === undefined) {
        toast({
          title: '입찰서 제출기간 미설정',
          description: '입찰서 제출 시작일 오프셋과 기간을 모두 설정해주세요.',
          variant: 'destructive',
        })
        return
      }
      if (!schedule.submissionStartTime || !schedule.submissionEndTime) {
        toast({
          title: '입찰서 제출시간 미설정',
          description: '입찰 시작 시간과 마감 시간을 모두 설정해주세요.',
          variant: 'destructive',
        })
        return
      }

      // 2. 선정된 업체들 조회 및 검증
      const vendors = await getSelectedVendors()
      if (vendors.length === 0) {
        toast({
          title: '선정된 업체 없음',
          description: '입찰에 참여할 업체가 없습니다.',
          variant: 'destructive',
        })
        return
      }

      // 3. 업체 담당자 검증
      const vendorsWithoutContacts = vendors.filter(vendor =>
        !vendor.contacts || vendor.contacts.length === 0
      )
      if (vendorsWithoutContacts.length > 0) {
        toast({
          title: '업체 담당자 정보 부족',
          description: `${vendorsWithoutContacts.length}개 업체의 담당자가 없습니다. 각 업체에 담당자를 추가해주세요.`,
          variant: 'destructive',
        })
        return
      }

      // 4. 입찰 품목 검증
      const prItems = await getPrItemsForBidding(biddingId)
      if (!prItems || prItems.length === 0) {
        toast({
          title: '입찰 품목 없음',
          description: '입찰에 포함할 품목이 없습니다.',
          variant: 'destructive',
        })
        return
      }

      // 모든 검증 통과 시 다이얼로그 열기
      setSelectedVendors(vendors)
      setIsBiddingInvitationDialogOpen(true)
    } catch (error) {
      console.error('입찰공고 검증 중 오류 발생:', error)
      toast({
        title: '오류',
        description: '입찰공고 검증 중 오류가 발생했습니다.',
        variant: 'destructive',
      })
    }
  }

  // 결재 상신 핸들러 - 결재 완료 시 실제 입찰 등록 실행
  const handleApprovalSubmit = async ({ approvers, title, attachments }: { approvers: string[], title: string, attachments?: File[] }) => {
    try {
      if (!session?.user?.id || !session.user.epId || !invitationData) {
        toast({
          title: '오류',
          description: '필요한 정보가 없습니다.',
          variant: 'destructive',
        })
        return
      }

      // 결재 상신
      const result = await requestBiddingInvitationWithApproval({
        biddingId,
        vendors: selectedVendors,
        message: invitationData.message || '',
        currentUser: {
          id: Number(session.user.id),
          epId: session.user.epId,
          email: session.user.email || undefined,
        },
        approvers,
        specificationMeeting: schedule.hasSpecificationMeeting ? {
          meetingDate: specMeetingInfo.meetingDate,
          meetingTime: specMeetingInfo.meetingTime,
          location: specMeetingInfo.location,
          address: specMeetingInfo.address,
          contactPerson: specMeetingInfo.contactPerson,
          contactPhone: specMeetingInfo.contactPhone,
          contactEmail: specMeetingInfo.contactEmail,
          agenda: specMeetingInfo.agenda,
          materials: specMeetingInfo.materials,
          notes: specMeetingInfo.notes,
        } : undefined,
      })

      if (result.status === 'pending_approval') {
        toast({
          title: '입찰초대 결재 상신 완료',
          description: `결재가 상신되었습니다. (ID: ${result.approvalId})`,
        })
        setIsApprovalDialogOpen(false)
        setIsBiddingInvitationDialogOpen(false)
        setInvitationData(null)
        router.refresh()
      }
    } catch (error) {
      console.error('결재 상신 중 오류 발생:', error)
      toast({
        title: '오류',
        description: '결재 상신 중 오류가 발생했습니다.',
        variant: 'destructive',
      })
    }
  }

  // 차수 증가된 입찰의 직접 입찰공고 함수 (결재 생략)
  const handleDirectBiddingInvitation = async (data: BiddingInvitationData, vendors: VendorContractRequirement[]) => {
    try {
      if (!session?.user?.id) {
        toast({
          title: '오류',
          description: '사용자 정보가 없습니다.',
          variant: 'destructive',
        })
        return
      }

      // 입찰 등록 (결재 생략)
      const result = await registerBidding(biddingId, session.user.id.toString())

      if (result.success) {
        toast({
          title: '입찰공고 완료',
          description: '차수 증가된 입찰이 성공적으로 공고되었습니다.',
        })

        // 다이얼로그 닫기 및 페이지 새로고침
        setIsBiddingInvitationDialogOpen(false)
        setInvitationData(null)
        router.refresh()
      } else {
        toast({
          title: '오류',
          description: result.error || '입찰공고 중 오류가 발생했습니다.',
          variant: 'destructive',
        })
      }
    } catch (error) {
      console.error('직접 입찰공고 중 오류 발생:', error)
      toast({
        title: '오류',
        description: '입찰공고 중 오류가 발생했습니다.',
        variant: 'destructive',
      })
    }
  }

  // 입찰 초대 발송 핸들러 - 결재 준비 및 결재 다이얼로그 열기
  const handleBiddingInvitationSend = async (data: BiddingInvitationData) => {
    try {
      if (!session?.user?.id) {
        toast({
          title: '오류',
          description: '사용자 정보가 없습니다.',
          variant: 'destructive',
        })
        return
      }

      // 선정된 업체들 조회
      const vendors = await getSelectedVendors()
      if (vendors.length === 0) {
        toast({
          title: '오류',
          description: '선정된 업체가 없습니다.',
          variant: 'destructive',
        })
        return
      }

      // 차수 증가된 입찰(02, 03 등)인지 확인
      if (isRoundIncreased(biddingInfo?.biddingNumber)) {
        // 차수 증가된 입찰은 결재 생략하고 바로 입찰 등록
        await handleDirectBiddingInvitation(data, vendors)
        return
      }

      // 일반 입찰의 경우 결재 데이터 준비 (템플릿 변수, 제목 등)
      const approvalData = await prepareBiddingApprovalData({
        biddingId,
        vendors,
        message: data.message || '',
        specificationMeeting: schedule.hasSpecificationMeeting ? {
          meetingDate: specMeetingInfo.meetingDate,
          meetingTime: specMeetingInfo.meetingTime,
          location: specMeetingInfo.location,
          address: specMeetingInfo.address,
          contactPerson: specMeetingInfo.contactPerson,
          contactPhone: specMeetingInfo.contactPhone,
          contactEmail: specMeetingInfo.contactEmail,
          agenda: specMeetingInfo.agenda,
          materials: specMeetingInfo.materials,
          notes: specMeetingInfo.notes,
        } : undefined,
      })

      // 결재 준비 완료 - invitationData와 결재 데이터 저장 및 결재 다이얼로그 열기
      setInvitationData(data)
      setApprovalVariables(approvalData.variables)
      setApprovalTitle(`입찰초대 - ${approvalData.bidding.title}`)
      setIsApprovalDialogOpen(true)
    } catch (error) {
      console.error('결재 준비 중 오류 발생:', error)
      toast({
        title: '오류',
        description: '결재 준비 중 오류가 발생했습니다.',
        variant: 'destructive',
      })
    }
  }

  const handleSave = async () => {
    setIsSubmitting(true)
    try {
      const userId = session?.user?.id?.toString() || '1'

      // 입찰서 제출기간 필수 검증
      if (schedule.submissionStartOffset === undefined || schedule.submissionDurationDays === undefined) {
        toast({
          title: '입찰서 제출기간 미설정',
          description: '입찰서 제출 시작일 오프셋과 기간을 모두 설정해주세요.',
          variant: 'destructive',
        })
        setIsSubmitting(false)
        return
      }
      if (!schedule.submissionStartTime || !schedule.submissionEndTime) {
        toast({
          title: '입찰서 제출시간 미설정',
          description: '입찰 시작 시간과 마감 시간을 모두 설정해주세요.',
          variant: 'destructive',
        })
        setIsSubmitting(false)
        return
      }
      // 오프셋/기간 검증
      if (schedule.submissionStartOffset < 0) {
        toast({
          title: '시작일 오프셋 오류',
          description: '시작일 오프셋은 0 이상이어야 합니다.',
          variant: 'destructive',
        })
        setIsSubmitting(false)
        return
      }
      if (schedule.submissionDurationDays < 1) {
        toast({
          title: '기간 오류',
          description: '입찰 기간은 최소 1일 이상이어야 합니다.',
          variant: 'destructive',
        })
        setIsSubmitting(false)
        return
      }
      // 긴급 입찰이 아닌 경우 당일 시작 불가 (오프셋 0)
      if (!schedule.isUrgent && schedule.submissionStartOffset === 0) {
        toast({
          title: '시작일 오류',
          description: '긴급 입찰이 아닌 경우 당일 시작(오프셋 0)은 불가능합니다.',
          variant: 'destructive',
        })
        setIsSubmitting(false)
        return
      }

      // 사양설명회 정보 유효성 검사
      if (schedule.hasSpecificationMeeting) {
        if (!specMeetingInfo.meetingDate || !specMeetingInfo.location || !specMeetingInfo.contactPerson) {
          toast({
            title: '오류',
            description: '사양설명회 필수 정보가 누락되었습니다. (회의일시, 장소, 담당자)',
            variant: 'destructive',
          })
          setIsSubmitting(false)
          return
        }
      }

      const result = await updateBiddingSchedule(
        biddingId, 
        schedule, 
        userId,
        schedule.hasSpecificationMeeting ? specMeetingInfo : undefined
      )

      if (result.success) {
        toast({
          title: '성공',
          description: '일정 정보가 성공적으로 저장되었습니다.',
        })
      } else {
        toast({
          title: '오류',
          description: 'error' in result ? result.error : '일정 정보 저장에 실패했습니다.',
          variant: 'destructive',
        })
      }
    } catch (error) {
      console.error('Failed to save schedule:', error)
      toast({
        title: '오류',
        description: '일정 정보 저장에 실패했습니다.',
        variant: 'destructive',
      })
    } finally {
      setIsSubmitting(false)
    }
  }

  const handleScheduleChange = (field: keyof BiddingSchedule, value: string | boolean | number) => {
    // 시작일 오프셋 검증
    if (field === 'submissionStartOffset' && typeof value === 'number') {
      if (value < 0) {
        toast({
          title: '시작일 오프셋 오류',
          description: '시작일 오프셋은 0 이상이어야 합니다.',
          variant: 'destructive',
        })
        return
      }
      // 긴급 입찰이 아닌 경우 당일 시작(오프셋 0) 불가
      if (!schedule.isUrgent && value === 0) {
        toast({
          title: '시작일 오프셋 오류',
          description: '긴급 입찰이 아닌 경우 당일 시작(오프셋 0)은 불가능합니다.',
          variant: 'destructive',
        })
        return
      }
    }

    // 기간 검증
    if (field === 'submissionDurationDays' && typeof value === 'number') {
      if (value < 1) {
        toast({
          title: '기간 오류',
          description: '입찰 기간은 최소 1일 이상이어야 합니다.',
          variant: 'destructive',
        })
        return
      }
    }

    // 시간 형식 검증 (HH:MM)
    if ((field === 'submissionStartTime' || field === 'submissionEndTime') && typeof value === 'string') {
      const timeRegex = /^([01]?[0-9]|2[0-3]):[0-5][0-9]$/
      if (value && !timeRegex.test(value)) {
        toast({
          title: '시간 형식 오류',
          description: '시간은 HH:MM 형식으로 입력해주세요.',
          variant: 'destructive',
        })
        return
      }
    }

    setSchedule(prev => ({ ...prev, [field]: value }))
    // 사양설명회 실시 여부가 false로 변경되어도 상세 정보 초기화하지 않음 (기존 데이터 유지)
  }

  if (isLoading) {
    return (
      <div className="flex items-center justify-center p-8">
        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-gray-900"></div>
        <span className="ml-2">일정 정보를 불러오는 중...</span>
      </div>
    )
  }

  return (
    <div className="space-y-6">
      <Card>
        <CardHeader>
          <CardTitle className="flex items-center gap-2">
            <Calendar className="h-5 w-5" />
            입찰 일정 관리
          </CardTitle>
          <p className="text-sm text-muted-foreground mt-1">
            입찰의 주요 일정들을 설정하고 관리합니다.
          </p>
        </CardHeader>
        <CardContent className="space-y-6">
          {/* 입찰서 제출 기간 */}
          <div className="space-y-4">
            <h3 className="text-lg font-medium flex items-center gap-2">
              <Clock className="h-4 w-4" />
              입찰서 제출 기간
            </h3>
            <p className="text-sm text-muted-foreground">
              입찰공고(결재 완료) 시점을 기준으로 일정이 자동 계산됩니다.
            </p>
            
            {/* 시작일 설정 */}
            <div className="grid grid-cols-2 gap-4">
              <div className="space-y-2">
                <Label htmlFor="submission-start-offset">시작일 (결재 후) <span className="text-red-500">*</span></Label>
                <div className="flex items-center gap-2">
                  <Input
                    id="submission-start-offset"
                    type="number"
                    min={schedule.isUrgent ? 0 : 1}
                    value={schedule.submissionStartOffset ?? ''}
                    onChange={(e) => handleScheduleChange('submissionStartOffset', parseInt(e.target.value) || 0)}
                    className={schedule.submissionStartOffset === undefined ? 'border-red-200' : ''}
                    disabled={readonly}
                    placeholder="0"
                  />
                  <span className="text-sm text-muted-foreground whitespace-nowrap">일 후</span>
                </div>
                {schedule.submissionStartOffset === undefined && (
                  <p className="text-sm text-red-500">시작일 오프셋은 필수입니다</p>
                )}
                {!schedule.isUrgent && schedule.submissionStartOffset === 0 && (
                  <p className="text-sm text-amber-600">긴급 입찰만 당일 시작(0일) 가능</p>
                )}
              </div>
              <div className="space-y-2">
                <Label htmlFor="submission-start-time">시작 시간 <span className="text-red-500">*</span></Label>
                <Input
                  id="submission-start-time"
                  type="time"
                  value={schedule.submissionStartTime || ''}
                  onChange={(e) => handleScheduleChange('submissionStartTime', e.target.value)}
                  className={!schedule.submissionStartTime ? 'border-red-200' : ''}
                  disabled={readonly}
                />
                {!schedule.submissionStartTime && (
                  <p className="text-sm text-red-500">시작 시간은 필수입니다</p>
                )}
              </div>
            </div>

            {/* 마감일 설정 */}
            <div className="grid grid-cols-2 gap-4">
              <div className="space-y-2">
                <Label htmlFor="submission-duration">입찰 기간 (시작일 +) <span className="text-red-500">*</span></Label>
                <div className="flex items-center gap-2">
                  <Input
                    id="submission-duration"
                    type="number"
                    min={1}
                    value={schedule.submissionDurationDays ?? ''}
                    onChange={(e) => handleScheduleChange('submissionDurationDays', parseInt(e.target.value) || 1)}
                    className={schedule.submissionDurationDays === undefined ? 'border-red-200' : ''}
                    disabled={readonly}
                    placeholder="7"
                  />
                  <span className="text-sm text-muted-foreground whitespace-nowrap">일간</span>
                </div>
                {schedule.submissionDurationDays === undefined && (
                  <p className="text-sm text-red-500">입찰 기간은 필수입니다</p>
                )}
              </div>
              <div className="space-y-2">
                <Label htmlFor="submission-end-time">마감 시간 <span className="text-red-500">*</span></Label>
                <Input
                  id="submission-end-time"
                  type="time"
                  value={schedule.submissionEndTime || ''}
                  onChange={(e) => handleScheduleChange('submissionEndTime', e.target.value)}
                  className={!schedule.submissionEndTime ? 'border-red-200' : ''}
                  disabled={readonly}
                />
                {!schedule.submissionEndTime && (
                  <p className="text-sm text-red-500">마감 시간은 필수입니다</p>
                )}
              </div>
            </div>

            {/* 예상 일정 미리보기 */}
            {schedule.submissionStartOffset !== undefined && schedule.submissionDurationDays !== undefined && (
              <div className="p-3 bg-blue-50 rounded-lg border border-blue-200">
                <p className="text-sm font-medium text-blue-800 mb-1">📅 예상 일정 (오늘 공고 기준)</p>
                <div className="text-sm text-blue-700">
                  <span>시작: {format(getPreviewDates().startDate, "yyyy-MM-dd HH:mm")}</span>
                  <span className="mx-2">~</span>
                  <span>마감: {format(getPreviewDates().endDate, "yyyy-MM-dd HH:mm")}</span>
                </div>
              </div>
            )}
          </div>

          {/* 긴급 여부 */}
          <div className="flex flex-row items-center justify-between rounded-lg border p-4">
            <div className="space-y-0.5">
              <Label className="text-base">긴급여부</Label>
              <p className="text-sm text-muted-foreground">
                긴급 입찰로 표시할 경우 활성화하세요
              </p>
            </div>
            <Switch
              checked={schedule.isUrgent || false}
              onCheckedChange={(checked) => handleScheduleChange('isUrgent', checked)}
              disabled={readonly}
            />
          </div>

          {/* 사양설명회 실시 여부 */}
          <div className="flex flex-row items-center justify-between rounded-lg border p-4">
            <div className="space-y-0.5">
              <Label className="text-base">사양설명회 실시</Label>
              <p className="text-sm text-muted-foreground">
                사양설명회를 실시할 경우 상세 정보를 입력하세요
              </p>
            </div>
            <Switch
              checked={schedule.hasSpecificationMeeting || false}
              onCheckedChange={(checked) => handleScheduleChange('hasSpecificationMeeting', checked)}
              disabled={readonly}
            />
          </div>

          {/* 사양설명회 상세 정보 - T/F와 무관하게 기존 데이터가 있거나 hasSpecificationMeeting이 true면 표시 */}
          {(schedule.hasSpecificationMeeting) && (
            <div className="space-y-6 p-4 border rounded-lg bg-muted/50">
              <div className="grid grid-cols-2 gap-4">
                <div>
                  <Label>회의일시 <span className="text-red-500">*</span></Label>
                  <Input
                    type="datetime-local"
                    value={specMeetingInfo.meetingDate}
                    onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, meetingDate: e.target.value }))}
                    className={!specMeetingInfo.meetingDate ? 'border-red-200' : ''}
                    disabled={readonly}
                    min="1900-01-01T00:00"
                    max="2100-12-31T23:59"
                  />
                  {!specMeetingInfo.meetingDate && (
                    <p className="text-sm text-red-500 mt-1">회의일시는 필수입니다</p>
                  )}
                </div>
                <div>
                  <Label>회의시간</Label>
                  <Input
                    placeholder="예: 14:00 ~ 16:00"
                    value={specMeetingInfo.meetingTime}
                    onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, meetingTime: e.target.value }))}
                    disabled={readonly}
                  />
                </div>
              </div>
              <div>
                <Label>장소 <span className="text-red-500">*</span></Label>
                <Input
                  placeholder="회의 장소"
                  value={specMeetingInfo.location}
                  onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, location: e.target.value }))}
                  className={!specMeetingInfo.location ? 'border-red-200' : ''}
                  disabled={readonly}
                />
                {!specMeetingInfo.location && (
                  <p className="text-sm text-red-500 mt-1">회의 장소는 필수입니다</p>
                )}
              </div>
              <div>
                <Label>주소</Label>
                <Input
                  placeholder="회의 장소 주소"
                  value={specMeetingInfo.address}
                  onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, address: e.target.value }))}
                  disabled={readonly}
                />
              </div>
              <div className="grid grid-cols-3 gap-4">
                <div>
                  <Label>담당자 <span className="text-red-500">*</span></Label>
                  <Input
                    placeholder="담당자명"
                    value={specMeetingInfo.contactPerson}
                    onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, contactPerson: e.target.value }))}
                    className={!specMeetingInfo.contactPerson ? 'border-red-200' : ''}
                    disabled={readonly}
                  />
                  {!specMeetingInfo.contactPerson && (
                    <p className="text-sm text-red-500 mt-1">담당자는 필수입니다</p>
                  )}
                </div>
                <div>
                  <Label>연락처</Label>
                  <Input
                    placeholder="전화번호"
                    value={specMeetingInfo.contactPhone}
                    onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, contactPhone: e.target.value }))}
                    disabled={readonly}
                  />
                </div>
                <div>
                  <Label>이메일</Label>
                  <Input
                    type="email"
                    placeholder="이메일"
                    value={specMeetingInfo.contactEmail}
                    onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, contactEmail: e.target.value }))}
                    disabled={readonly}
                  />
                </div>
              </div>
              <div>
                <Label>안건</Label>
                <Textarea
                  placeholder="회의 안건을 입력하세요"
                  value={specMeetingInfo.agenda}
                  onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, agenda: e.target.value }))}
                  rows={3}
                  disabled={readonly}
                />
              </div>
              <div>
                <Label>자료</Label>
                <Textarea
                  placeholder="회의 자료 정보를 입력하세요"
                  value={specMeetingInfo.materials}
                  onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, materials: e.target.value }))}
                  rows={3}
                  disabled={readonly}
                />
              </div>
              <div>
                <Label>비고</Label>
                <Textarea
                  placeholder="추가 사항을 입력하세요"
                  value={specMeetingInfo.notes}
                  onChange={(e) => setSpecMeetingInfo((prev) => ({ ...prev, notes: e.target.value }))}
                  rows={3}
                  disabled={readonly}
                />
              </div>
            </div>
          )}

          {/* 비고 */}
          <div className="space-y-4">
            <h3 className="text-lg font-medium">비고</h3>
            <div className="space-y-2">
              <Label htmlFor="remarks">추가 사항</Label>
              <Textarea
                id="remarks"
                value={schedule.remarks || ''}
                onChange={(e) => handleScheduleChange('remarks', e.target.value)}
                placeholder="일정에 대한 추가 설명이나 참고사항을 입력하세요"
                rows={4}
                disabled={readonly}
              />
            </div>
          </div>
        </CardContent>
      </Card>

      {/* 일정 요약 카드 */}
      <Card>
        <CardHeader>
          <CardTitle>일정 요약</CardTitle>
        </CardHeader>
        <CardContent>
          <div className="space-y-2 text-sm">
            <div className="flex justify-between">
              <span className="font-medium">시작일:</span>
              <span>
                {schedule.submissionStartOffset !== undefined
                  ? `결재 후 ${schedule.submissionStartOffset}일, ${schedule.submissionStartTime || '미설정'}`
                  : '미설정'
                }
              </span>
            </div>
            <div className="flex justify-between">
              <span className="font-medium">마감일:</span>
              <span>
                {schedule.submissionDurationDays !== undefined
                  ? `시작일 + ${schedule.submissionDurationDays}일, ${schedule.submissionEndTime || '미설정'}`
                  : '미설정'
                }
              </span>
            </div>
            <div className="flex justify-between">
              <span className="font-medium">긴급여부:</span>
              <span>
                {schedule.isUrgent ? '예' : '아니오'}
              </span>
            </div>
            <div className="flex justify-between">
              <span className="font-medium">사양설명회 실시:</span>
              <span>
                {schedule.hasSpecificationMeeting ? '예' : '아니오'}
              </span>
            </div>
            {schedule.hasSpecificationMeeting && specMeetingInfo.meetingDate && (
              <div className="flex justify-between">
                <span className="font-medium">사양설명회 일시:</span>
                <span>
                  {format(new Date(specMeetingInfo.meetingDate), "yyyy-MM-dd HH:mm")}
                </span>
              </div>
            )}
          </div>
        </CardContent>
      </Card>

      {/* 액션 버튼 */}
      {!readonly && (
        <div className="flex justify-between gap-4">
          <Button
            variant="default"
            onClick={handleBiddingInvitationClick}
            disabled={!biddingInfo || biddingInfo.status !== 'bidding_generated'}
            className="min-w-[120px]"
          >
            <Send className="w-4 h-4 mr-2" />
            입찰공고
          </Button>
          <div className="flex gap-4">
            <Button
              onClick={handleSave}
              disabled={isSubmitting || !biddingInfo || biddingInfo.status !== 'bidding_generated'}
              className="min-w-[120px]"
            >
              {isSubmitting ? (
                <>
                  <RefreshCw className="w-4 h-4 mr-2 animate-spin" />
                  저장 중...
                </>
              ) : (
                <>
                  <Save className="w-4 h-4 mr-2" />
                  저장
                </>
              )}
            </Button>
          </div>
        </div>
      )}

      {/* 입찰 초대 다이얼로그 */}
      {biddingInfo && (
        <BiddingInvitationDialog
          open={isBiddingInvitationDialogOpen}
          onOpenChange={setIsBiddingInvitationDialogOpen}
          vendors={selectedVendors}
          biddingId={biddingId}
          biddingTitle={biddingInfo.title}
          onSend={handleBiddingInvitationSend}
        />
      )}

      {/* 입찰초대 결재 다이얼로그 */}
      {session?.user && session.user.epId && biddingInfo && invitationData && Object.keys(approvalVariables).length > 0 && (
        <ApprovalPreviewDialog
          open={isApprovalDialogOpen}
          onOpenChange={(open) => {
            setIsApprovalDialogOpen(open)
            if (!open) {
              // 다이얼로그가 닫히면 결재 변수 초기화
              setApprovalVariables({})
              setApprovalTitle('')
              setInvitationData(null)
            }
          }}
          templateName="입찰초대 결재"
          variables={approvalVariables}
          title={approvalTitle}
          currentUser={{
            id: Number(session.user.id),
            epId: session.user.epId,
            name: session.user.name || undefined,
            email: session.user.email || undefined
          }}
          onConfirm={handleApprovalSubmit}
        />
      )}
    </div>
  )
}