/**
 * 메일 관리 시스템 API 클라이언트
 * 파일 기반 메일 계정 및 템플릿 관리
 */

// API 기본 URL
const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || "/api";

// ============================================
// 타입 정의
// ============================================

export interface MailAccount {
  id: string;
  name: string;
  email: string;
  smtpHost: string;
  smtpPort: number;
  smtpSecure: boolean;
  smtpUsername: string;
  smtpPassword: string; // 암호화된 상태
  dailyLimit: number;
  status: 'active' | 'inactive';
  createdAt: string;
  updatedAt: string;
}

export interface CreateMailAccountDto {
  name: string;
  email: string;
  smtpHost: string;
  smtpPort: number;
  smtpSecure: boolean;
  smtpUsername: string;
  smtpPassword: string;
  dailyLimit?: number;
}

export interface UpdateMailAccountDto extends Partial<CreateMailAccountDto> {
  status?: 'active' | 'inactive';
}

export interface MailComponent {
  id: string;
  type: 'text' | 'button' | 'image' | 'spacer' | 'header' | 'infoTable' | 'alertBox' | 'divider' | 'footer' | 'numberedList';
  content?: string;
  text?: string;
  url?: string;
  src?: string;
  height?: number;
  styles?: Record<string, string>;
  // 헤더 컴포넌트용
  logoSrc?: string;
  brandName?: string;
  sendDate?: string;
  headerBgColor?: string;
  // 정보 테이블용
  rows?: Array<{ label: string; value: string }>;
  tableTitle?: string;
  // 강조 박스용
  alertType?: 'info' | 'warning' | 'danger' | 'success';
  alertTitle?: string;
  // 푸터용
  companyName?: string;
  ceoName?: string;
  businessNumber?: string;
  address?: string;
  phone?: string;
  email?: string;
  copyright?: string;
  // 번호 리스트용
  listItems?: string[];
  listTitle?: string;
}

export interface MailTemplate {
  id: string;
  name: string;
  subject: string;
  components: MailComponent[];
  category?: string;
  createdAt: string;
  updatedAt: string;
}

export interface CreateMailTemplateDto {
  name: string;
  subject: string;
  components: MailComponent[];
  category?: string;
}

export interface UpdateMailTemplateDto extends Partial<CreateMailTemplateDto> {}

export interface SendMailDto {
  accountId: string;
  templateId?: string;
  to: string[]; // 받는 사람
  cc?: string[]; // 참조 (Carbon Copy)
  bcc?: string[]; // 숨은참조 (Blind Carbon Copy)
  subject: string;
  variables?: Record<string, string>; // 템플릿 변수 치환
  customHtml?: string; // 템플릿 없이 직접 HTML 작성 시
}

// ============================================
// 발송 이력 타입
// ============================================

export interface AttachmentInfo {
  filename: string;
  originalName: string;
  size: number;
  path: string;
  mimetype: string;
}

export interface SentMailHistory {
  id: string;
  accountId: string;
  accountName: string;
  accountEmail: string;
  to: string[];
  cc?: string[];
  bcc?: string[];
  subject: string;
  htmlContent: string;
  templateId?: string;
  templateName?: string;
  attachments?: AttachmentInfo[];
  sentAt: string;
  status: 'success' | 'failed' | 'draft';
  messageId?: string;
  errorMessage?: string;
  accepted?: string[];
  rejected?: string[];
  isDraft?: boolean;
  deletedAt?: string;
  updatedAt?: string;
}

export interface SentMailListQuery {
  page?: number;
  limit?: number;
  searchTerm?: string;
  status?: 'success' | 'failed' | 'draft' | 'all';
  accountId?: string;
  startDate?: string;
  endDate?: string;
  sortBy?: 'sentAt' | 'subject' | 'updatedAt';
  sortOrder?: 'asc' | 'desc';
  includeDeleted?: boolean;
  onlyDeleted?: boolean;
}

export interface SentMailListResponse {
  items: SentMailHistory[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
}

export interface MailStatistics {
  totalSent: number;
  successCount: number;
  failedCount: number;
  todayCount: number;
  thisMonthCount: number;
  successRate: number;
}

export interface MailSendResult {
  success: boolean;
  messageId?: string;
  error?: string;
}

// ============================================
// API 기본 설정
// ============================================

import { apiClient } from './client';

async function fetchApi<T>(
  endpoint: string,
  options: { method?: string; data?: unknown } = {}
): Promise<T> {
  const { method = 'GET', data } = options;
  
  try {
    const response = await apiClient({
      url: endpoint, // `/mail` 접두사 제거 (apiClient는 이미 /api를 포함)
      method,
      data,
    });

    // 백엔드가 { success: true, data: ... } 형식으로 반환하는 경우 처리
    if (response.data.success && response.data.data !== undefined) {
      return response.data.data as T;
    }
    
    return response.data as T;
  } catch (error: unknown) {
    if (error && typeof error === 'object' && 'response' in error) {
      const axiosError = error as { response?: { data?: { message?: string }; status?: number } };
      throw new Error(axiosError.response?.data?.message || `HTTP ${axiosError.response?.status}`);
    }
    throw new Error('Unknown error');
  }
}

// ============================================
// 메일 계정 API
// ============================================

/**
 * 전체 메일 계정 목록 조회
 */
export async function getMailAccounts(): Promise<MailAccount[]> {
  return fetchApi<MailAccount[]>('/mail/accounts');
}

/**
 * 특정 메일 계정 조회
 */
export async function getMailAccount(id: string): Promise<MailAccount> {
  return fetchApi<MailAccount>(`/mail/accounts/${id}`);
}

/**
 * 메일 계정 생성
 */
export async function createMailAccount(
  data: CreateMailAccountDto
): Promise<MailAccount> {
  return fetchApi<MailAccount>('/mail/accounts', {
    method: 'POST',
    data,
  });
}

/**
 * 메일 계정 수정
 */
export async function updateMailAccount(
  id: string,
  data: UpdateMailAccountDto
): Promise<MailAccount> {
  return fetchApi<MailAccount>(`/mail/accounts/${id}`, {
    method: 'PUT',
    data,
  });
}

/**
 * 메일 계정 삭제
 */
export async function deleteMailAccount(id: string): Promise<{ success: boolean }> {
  return fetchApi<{ success: boolean }>(`/mail/accounts/${id}`, {
    method: 'DELETE',
  });
}

/**
 * SMTP 연결 테스트
 */
export async function testMailAccountConnection(id: string): Promise<{ success: boolean; message: string }> {
  return fetchApi<{ success: boolean; message: string }>(`/mail/accounts/${id}/test-connection`, {
    method: 'POST',
  });
}

/**
 * SMTP 연결 테스트
 */
export async function testMailConnection(id: string): Promise<{
  success: boolean;
  message: string;
}> {
  return fetchApi<{ success: boolean; message: string }>(
    `/mail/accounts/${id}/test-connection`,
    {
      method: 'POST',
    }
  );
}

// ============================================
// 메일 템플릿 API
// ============================================

/**
 * 전체 메일 템플릿 목록 조회
 */
export async function getMailTemplates(): Promise<MailTemplate[]> {
  return fetchApi<MailTemplate[]>('/mail/templates-file');
}

/**
 * 특정 메일 템플릿 조회
 */
export async function getMailTemplate(id: string): Promise<MailTemplate> {
  return fetchApi<MailTemplate>(`/mail/templates-file/${id}`);
}

/**
 * 메일 템플릿 생성
 */
export async function createMailTemplate(
  data: CreateMailTemplateDto
): Promise<MailTemplate> {
  return fetchApi<MailTemplate>('/mail/templates-file', {
    method: 'POST',
    data,
  });
}

/**
 * 메일 템플릿 수정
 */
export async function updateMailTemplate(
  id: string,
  data: UpdateMailTemplateDto
): Promise<MailTemplate> {
  return fetchApi<MailTemplate>(`/mail/templates-file/${id}`, {
    method: 'PUT',
    data,
  });
}

/**
 * 메일 템플릿 삭제
 */
export async function deleteMailTemplate(id: string): Promise<{ success: boolean }> {
  return fetchApi<{ success: boolean }>(`/mail/templates-file/${id}`, {
    method: 'DELETE',
  });
}

/**
 * 메일 템플릿 미리보기 (샘플 데이터)
 */
export async function previewMailTemplate(
  id: string,
  sampleData?: Record<string, string>
): Promise<{ html: string }> {
  return fetchApi<{ html: string }>(`/mail/templates-file/${id}/preview`, {
    method: 'POST',
    data: { sampleData },
  });
}

// ============================================
// 메일 발송 API (간단한 버전 - 쿼리 제외)
// ============================================

/**
 * 메일 발송 (단건 또는 소규모 발송)
 */
export async function sendMail(data: SendMailDto): Promise<MailSendResult> {
  return fetchApi<MailSendResult>('/mail/send/simple', {
    method: 'POST',
    data,
  });
}

/**
 * 대량 메일 발송
 */
export interface BulkSendRequest {
  accountId: string;
  templateId?: string; // 템플릿 ID (선택)
  customHtml?: string; // 직접 작성한 HTML (선택)
  subject: string;
  recipients: Array<{
    email: string;
    variables?: Record<string, string>; // 템플릿 사용 시에만 필요
  }>;
  onProgress?: (sent: number, total: number) => void;
}

export interface BulkSendResult {
  total: number;
  success: number;
  failed: number;
  results: Array<{
    email: string;
    success: boolean;
    messageId?: string;
    error?: string;
  }>;
}

export async function sendBulkMail(request: BulkSendRequest): Promise<BulkSendResult> {
  const { onProgress, ...data } = request;
  
  // 프로그레스 콜백이 있으면 시뮬레이션 (실제로는 서버에서 스트리밍 필요)
  if (onProgress) {
    onProgress(0, data.recipients.length);
  }
  
  const result = await fetchApi<BulkSendResult>('/mail/send/bulk', {
    method: 'POST',
    data,
  });
  
  if (onProgress) {
    onProgress(result.success, result.total);
  }
  
  return result;
}

/**
 * 템플릿 변수 추출 (템플릿에서 {변수명} 형식 추출)
 */
export function extractTemplateVariables(template: MailTemplate): string[] {
  const variableRegex = /\{(\w+)\}/g;
  const variables = new Set<string>();

  // subject에서 추출
  const subjectMatches = template.subject.matchAll(variableRegex);
  for (const match of subjectMatches) {
    variables.add(match[1]);
  }

  // 컴포넌트 content에서 추출
  template.components.forEach((component) => {
    if (component.content) {
      const contentMatches = component.content.matchAll(variableRegex);
      for (const match of contentMatches) {
        variables.add(match[1]);
      }
    }
    if (component.text) {
      const textMatches = component.text.matchAll(variableRegex);
      for (const match of textMatches) {
        variables.add(match[1]);
      }
    }
  });

  return Array.from(variables);
}

/**
 * 템플릿을 HTML로 렌더링 (프론트엔드 미리보기용)
 */
export function renderTemplateToHtml(
  template: MailTemplate,
  variables?: Record<string, string>
): string {
  let html = '<div style="max-width: 600px; margin: 0 auto; font-family: Arial, sans-serif;">';

  template.components.forEach((component) => {
    switch (component.type) {
      case 'text':
        let content = component.content || '';
        if (variables) {
          Object.entries(variables).forEach(([key, value]) => {
            content = content.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
          });
        }
        html += `<div style="${styleObjectToString(component.styles)}">${content}</div>`;
        break;

      case 'button':
        let buttonText = component.text || 'Button';
        if (variables) {
          Object.entries(variables).forEach(([key, value]) => {
            buttonText = buttonText.replace(new RegExp(`\\{${key}\\}`, 'g'), value);
          });
        }
        html += `
          <a href="${component.url || '#'}" style="
            display: inline-block;
            padding: 12px 24px;
            background-color: #007bff;
            color: white;
            text-decoration: none;
            border-radius: 4px;
            ${styleObjectToString(component.styles)}
          ">${buttonText}</a>
        `;
        break;

      case 'image':
        html += `<img src="${component.src || ''}" style="max-width: 100%; ${styleObjectToString(component.styles)}" />`;
        break;

      case 'spacer':
        html += `<div style="height: ${component.height || 20}px;"></div>`;
        break;

      case 'header':
        html += `
          <div style="padding: 20px; background-color: ${component.headerBgColor || '#f8f9fa'}; border-radius: 8px; margin-bottom: 20px;">
            <table style="width: 100%;">
              <tr>
                <td style="vertical-align: middle;">
                  ${component.logoSrc ? `<img src="${component.logoSrc}" alt="로고" style="height: 40px; margin-right: 12px;">` : ''}
                  <span style="font-size: 18px; font-weight: bold;">${component.brandName || ''}</span>
                </td>
                <td style="text-align: right; color: #6b7280; font-size: 14px;">
                  ${component.sendDate || ''}
                </td>
              </tr>
            </table>
          </div>
        `;
        break;

      case 'infoTable':
        html += `
          <div style="border: 1px solid #e5e7eb; border-radius: 8px; overflow: hidden; margin: 16px 0;">
            ${component.tableTitle ? `<div style="background-color: #f9fafb; padding: 12px 16px; font-weight: 600; border-bottom: 1px solid #e5e7eb;">${component.tableTitle}</div>` : ''}
            <table style="width: 100%; border-collapse: collapse;">
              ${(component.rows || []).map((row, i) => `
                <tr style="background-color: ${i % 2 === 0 ? '#ffffff' : '#f9fafb'};">
                  <td style="padding: 12px 16px; font-weight: 500; color: #4b5563; width: 35%; border-right: 1px solid #e5e7eb;">${row.label}</td>
                  <td style="padding: 12px 16px;">${row.value}</td>
                </tr>
              `).join('')}
            </table>
          </div>
        `;
        break;

      case 'alertBox':
        const alertColors = {
          info: { bg: '#eff6ff', border: '#3b82f6', text: '#1e40af' },
          warning: { bg: '#fffbeb', border: '#f59e0b', text: '#92400e' },
          danger: { bg: '#fef2f2', border: '#ef4444', text: '#991b1b' },
          success: { bg: '#ecfdf5', border: '#10b981', text: '#065f46' }
        };
        const colors = alertColors[component.alertType || 'info'];
        html += `
          <div style="padding: 16px; background-color: ${colors.bg}; border-left: 4px solid ${colors.border}; border-radius: 4px; margin: 16px 0; color: ${colors.text};">
            ${component.alertTitle ? `<div style="font-weight: bold; margin-bottom: 8px;">${component.alertTitle}</div>` : ''}
            <div>${component.content || ''}</div>
          </div>
        `;
        break;

      case 'divider':
        html += `<hr style="border: none; border-top: ${component.height || 1}px solid #e5e7eb; margin: 20px 0;">`;
        break;

      case 'footer':
        html += `
          <div style="text-align: center; padding: 24px 16px; background-color: #f9fafb; border-top: 1px solid #e5e7eb; font-size: 14px; color: #6b7280;">
            ${component.companyName ? `<div style="font-weight: 600; color: #374151; margin-bottom: 8px;">${component.companyName}</div>` : ''}
            ${(component.ceoName || component.businessNumber) ? `
              <div style="margin-bottom: 4px;">
                ${component.ceoName ? `대표: ${component.ceoName}` : ''}
                ${component.ceoName && component.businessNumber ? ' | ' : ''}
                ${component.businessNumber ? `사업자등록번호: ${component.businessNumber}` : ''}
              </div>
            ` : ''}
            ${component.address ? `<div style="margin-bottom: 4px;">${component.address}</div>` : ''}
            ${(component.phone || component.email) ? `
              <div style="margin-bottom: 4px;">
                ${component.phone ? `Tel: ${component.phone}` : ''}
                ${component.phone && component.email ? ' | ' : ''}
                ${component.email ? `Email: ${component.email}` : ''}
              </div>
            ` : ''}
            ${component.copyright ? `<div style="margin-top: 12px; font-size: 12px; color: #9ca3af;">${component.copyright}</div>` : ''}
          </div>
        `;
        break;

      case 'numberedList':
        html += `
          <div style="padding: 16px; ${styleObjectToString(component.styles)}">
            ${component.listTitle ? `<div style="font-weight: 600; margin-bottom: 12px;">${component.listTitle}</div>` : ''}
            <ol style="margin: 0; padding-left: 20px;">
              ${(component.listItems || []).map(item => `<li style="margin-bottom: 8px;">${item}</li>`).join('')}
            </ol>
          </div>
        `;
        break;
    }
  });

  html += '</div>';
  return html;
}

function styleObjectToString(styles?: Record<string, string>): string {
  if (!styles) return '';
  return Object.entries(styles)
    .map(([key, value]) => `${camelToKebab(key)}: ${value}`)
    .join('; ');
}

function camelToKebab(str: string): string {
  return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
}

// ============================================
// 📥 메일 수신 API (Step 2)
// ============================================

export interface ReceivedMail {
  id: string;
  messageId: string;
  from: string;
  to: string;
  subject: string;
  date: string;
  preview: string;
  isRead: boolean;
  hasAttachments: boolean;
}

export interface MailDetail extends ReceivedMail {
  htmlBody: string;
  textBody: string;
  cc?: string;
  bcc?: string;
  attachments: Array<{
    filename: string;
    contentType: string;
    size: number;
  }>;
}

/**
 * 받은 메일 목록 조회
 */
export async function getReceivedMails(
  accountId: string,
  limit: number = 50
): Promise<ReceivedMail[]> {
  return fetchApi<ReceivedMail[]>(`/mail/receive/${accountId}?limit=${limit}`);
}

/**
 * 오늘 수신한 메일 수 조회 (통계)
 */
export async function getTodayReceivedCount(accountId?: string): Promise<number> {
  const params = accountId ? `?accountId=${accountId}` : '';
  const response = await fetchApi<{ count: number }>(`/mail/receive/today-count${params}`);
  return response.count;
}

/**
 * 메일 상세 조회
 */
export async function getMailDetail(
  accountId: string,
  seqno: number
): Promise<MailDetail> {
  return fetchApi<MailDetail>(`/mail/receive/${accountId}/${seqno}`);
}

/**
 * 메일 첨부파일 다운로드
 */
export async function downloadMailAttachment(
  accountId: string,
  seqno: number,
  attachmentIndex: number
): Promise<Blob> {
  const token = localStorage.getItem('authToken');
  const response = await fetch(
    `${API_BASE_URL}/mail/receive/${accountId}/${seqno}/attachment/${attachmentIndex}`,
    {
      headers: {
        Authorization: `Bearer ${token}`,
      },
    }
  );

  if (!response.ok) {
    throw new Error(`첨부파일 다운로드 실패: ${response.status}`);
  }

  return response.blob();
}

/**
 * 메일을 읽음으로 표시
 */
export async function markMailAsRead(
  accountId: string,
  seqno: number
): Promise<{ success: boolean; message: string }> {
  return fetchApi(`/mail/receive/${accountId}/${seqno}/mark-read`, {
    method: 'POST',
  });
}

/**
 * IMAP 연결 테스트
 */
export async function testImapConnection(
  accountId: string
): Promise<{ success: boolean; message: string }> {
  return fetchApi(`/mail/receive/${accountId}/test-imap`, {
    method: 'POST',
  });
}

// ============================================
// 발송 이력 API
// ============================================

/**
 * 발송 이력 목록 조회
 */
export async function getSentMailList(
  query: SentMailListQuery = {}
): Promise<SentMailListResponse> {
  const params = new URLSearchParams();
  
  if (query.page) params.append('page', query.page.toString());
  if (query.limit) params.append('limit', query.limit.toString());
  if (query.searchTerm) params.append('searchTerm', query.searchTerm);
  if (query.status && query.status !== 'all') params.append('status', query.status);
  if (query.accountId) params.append('accountId', query.accountId);
  if (query.startDate) params.append('startDate', query.startDate);
  if (query.endDate) params.append('endDate', query.endDate);
  if (query.sortBy) params.append('sortBy', query.sortBy);
  if (query.sortOrder) params.append('sortOrder', query.sortOrder);
  if (query.includeDeleted) params.append('includeDeleted', 'true');
  if (query.onlyDeleted) params.append('onlyDeleted', 'true');

  return fetchApi(`/mail/sent?${params.toString()}`);
}

/**
 * 특정 발송 이력 상세 조회
 */
export async function getSentMailById(id: string): Promise<SentMailHistory> {
  return fetchApi(`/mail/sent/${id}`);
}

/**
 * 발송 이력 삭제 (Soft Delete)
 */
export async function deleteSentMail(id: string): Promise<{ success: boolean; message: string }> {
  return fetchApi(`/mail/sent/${id}`, {
    method: 'DELETE',
  });
}

/**
 * 임시 저장 (Draft)
 */
export async function saveDraft(data: Partial<SentMailHistory> & { accountId: string }): Promise<SentMailHistory> {
  const response = await apiClient.post('/mail/sent/draft', data);
  return response.data.data;
}

/**
 * 임시 저장 업데이트
 */
export async function updateDraft(id: string, data: Partial<SentMailHistory>): Promise<SentMailHistory> {
  const response = await apiClient.put(`/mail/sent/draft/${id}`, data);
  return response.data.data;
}

/**
 * 메일 복구
 */
export async function restoreMail(id: string): Promise<{ success: boolean; message: string }> {
  return fetchApi(`/mail/sent/${id}/restore`, {
    method: 'POST',
  });
}

/**
 * 메일 영구 삭제
 */
export async function permanentlyDeleteMail(id: string): Promise<{ success: boolean; message: string }> {
  return fetchApi(`/mail/sent/${id}/permanent`, {
    method: 'DELETE',
  });
}

/**
 * 일괄 삭제
 */
export async function bulkDeleteMails(ids: string[]): Promise<{ success: boolean; message: string; data: { successCount: number; failCount: number } }> {
  return fetchApi('/mail/sent/bulk/delete', {
    method: 'POST',
    body: JSON.stringify({ ids }),
  });
}

/**
 * 일괄 영구 삭제
 */
export async function bulkPermanentlyDeleteMails(ids: string[]): Promise<{ success: boolean; message: string; data: { successCount: number; failCount: number } }> {
  return fetchApi('/mail/sent/bulk/permanent-delete', {
    method: 'POST',
    body: JSON.stringify({ ids }),
  });
}

/**
 * 일괄 복구
 */
export async function bulkRestoreMails(ids: string[]): Promise<{ success: boolean; message: string; data: { successCount: number; failCount: number } }> {
  return fetchApi('/mail/sent/bulk/restore', {
    method: 'POST',
    body: JSON.stringify({ ids }),
  });
}

/**
 * 메일 발송 통계 조회
 */
export async function getMailStatistics(accountId?: string): Promise<MailStatistics> {
  const params = accountId ? `?accountId=${accountId}` : '';
  return fetchApi(`/mail/sent/statistics${params}`);
}