/**
 * CENTRAL EMAIL FORMATTING UTILITY
 * 
 * This is the centralized email formatting utility used throughout the application.
 * It provides consistent handling of email content, sanitization, and text direction.
 * 
 * All code that needs to format email content should import from this file.
 * Text direction is preserved based on content language for proper RTL/LTR display.
 */

import DOMPurify from 'isomorphic-dompurify';
// Instead of importing, implement the formatDateRelative function directly
// import { formatDateRelative } from './date-formatter';

/**
 * Format a date in a relative format
 * Simple implementation for email display
 */
function formatDateRelative(date: Date): string {
  if (!date) return '';
  
  try {
    return date.toLocaleString('en-US', {
      weekday: 'short',
      year: 'numeric',
      month: 'short',
      day: 'numeric',
      hour: '2-digit',
      minute: '2-digit'
    });
  } catch (e) {
    return date.toString();
  }
}

// Reset any existing hooks to start clean
DOMPurify.removeAllHooks();

// Configure DOMPurify for English-only content (always LTR)
DOMPurify.addHook('afterSanitizeAttributes', function(node) {
  // We no longer force LTR direction on all elements
  // This allows the natural text direction to be preserved
  if (node instanceof HTMLElement) {
    // Only set direction if not already specified
    if (!node.hasAttribute('dir')) {
      // Add dir attribute only if not present
      node.setAttribute('dir', 'auto');
    }
    
    // Don't forcibly modify text alignment or direction in style attributes
    // This allows the component to control text direction instead
  }
});

// Configure DOMPurify to preserve direction attributes
DOMPurify.setConfig({
  ADD_ATTR: ['dir'],
  ALLOWED_ATTR: ['style', 'class', 'id', 'dir']
});

// Note: We ensure LTR text direction is applied in the component level
// when rendering email content

// Interface definitions
export interface EmailAddress {
  name: string;
  address: string;
}

export interface EmailMessage {
  id: string;
  messageId?: string;
  subject: string;
  from: EmailAddress[];
  to: EmailAddress[];
  cc?: EmailAddress[];
  bcc?: EmailAddress[];
  date: Date | string;
  flags?: {
    seen: boolean;
    flagged: boolean;
    answered: boolean;
    deleted: boolean;
    draft: boolean;
  };
  preview?: string;
  content?: string;
  html?: string;
  text?: string;
  hasAttachments?: boolean;
  attachments?: any[];
  folder?: string;
  size?: number;
  contentFetched?: boolean;
}

interface EmailContent {
  html?: string;
  text?: string;
}

/**
 * Format email addresses for display
 */
export function formatEmailAddresses(addresses: EmailAddress[]): string {
  if (!addresses || addresses.length === 0) return '';
  
  return addresses.map(addr => 
    addr.name && addr.name !== addr.address 
      ? `${addr.name} <${addr.address}>`
      : addr.address
  ).join(', ');
}

/**
 * Format date for display
 */
export function formatEmailDate(date: Date | string | undefined): string {
  if (!date) return '';
  
  try {
    const dateObj = typeof date === 'string' ? new Date(date) : date;
    return dateObj.toLocaleString('en-US', {
      weekday: 'short',
      year: 'numeric',
      month: 'short',
      day: 'numeric',
      hour: '2-digit',
      minute: '2-digit'
    });
  } catch (e) {
    return typeof date === 'string' ? date : date.toString();
  }
}

/**
 * Sanitize HTML content before processing or displaying
 * Implements email industry standards for proper, consistent, and secure rendering
 * 
 * @param html HTML content to sanitize
 * @returns Sanitized HTML with preserved styling and structure
 */
export function sanitizeHtml(html: string): string {
  if (!html) return '';
  
  try {
    // Use DOMPurify with comprehensive email HTML standards
    const clean = DOMPurify.sanitize(html, {
      ADD_TAGS: [
        'html', 'head', 'body', 'style', 'link', 'meta', 'title',
        'table', 'caption', 'col', 'colgroup', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th',
        'div', 'span', 'img', 'br', 'hr', 'section', 'article', 'header', 'footer',
        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'blockquote', 'pre', 'code',
        'ul', 'ol', 'li', 'dl', 'dt', 'dd', 'a', 'b', 'i', 'u', 'em',
        'strong', 'del', 'ins', 'mark', 'small', 'sub', 'sup', 'q', 'abbr'
      ],
      ADD_ATTR: [
        'style', 'class', 'id', 'name', 'href', 'src', 'alt', 'title', 'width', 'height',
        'border', 'cellspacing', 'cellpadding', 'bgcolor', 'background', 'color',
        'align', 'valign', 'dir', 'lang', 'target', 'rel', 'charset', 'media',
        'colspan', 'rowspan', 'scope', 'span', 'size', 'face', 'hspace', 'vspace',
        'data-*'
      ],
      KEEP_CONTENT: true,
      WHOLE_DOCUMENT: false,
      ALLOW_DATA_ATTR: true,
      ALLOW_UNKNOWN_PROTOCOLS: true, // Needed for some email clients
      FORBID_TAGS: ['script', 'iframe', 'object', 'embed', 'form', 'input', 'button', 'select', 'textarea'],
      FORBID_ATTR: ['onerror', 'onload', 'onclick', 'onmouseover', 'onmouseout'],
      FORCE_BODY: false
    });
    
    // Fix common email rendering issues
    return clean
      // Fix for Outlook WebVML content
      .replace(/<!--\[if\s+gte\s+mso/g, '<!--[if gte mso')
      // Fix for broken image paths that might be relative
      .replace(/(src|background)="(?!http|data|https|cid)/gi, '$1="https://');
  } catch (e) {
    console.error('Error sanitizing HTML:', e);
    // Fall back to a basic sanitization approach
    return html
      .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
      .replace(/on\w+="[^"]*"/g, '')
      .replace(/(javascript|jscript|vbscript|mocha):/gi, 'removed:');
  }
}

/**
 * Format an email for forwarding - CENTRAL IMPLEMENTATION
 * All other formatting functions should be deprecated in favor of this one
 */
export function formatForwardedEmail(email: EmailMessage): {
  subject: string;
  content: string;
} {
  // Format subject with Fwd: prefix if needed
  const subjectBase = email.subject || '(No subject)';
  const subject = subjectBase.match(/^(Fwd|FW|Forward):/i) 
    ? subjectBase 
    : `Fwd: ${subjectBase}`;
  
  // Get sender and recipient information
  const fromString = formatEmailAddresses(email.from || []);
  const toString = formatEmailAddresses(email.to || []);
  const dateString = formatEmailDate(email.date);
  
  // Get and sanitize original content (sanitization preserves content direction)
  const originalContent = sanitizeHtml(email.content || email.html || email.text || '');
  
  // Check if the content already has a forwarded message header
  const hasExistingHeader = originalContent.includes('---------- Forwarded message ---------');
  
  // If there's already a forwarded message header, don't add another one
  if (hasExistingHeader) {
    // Just wrap the content without additional formatting
    const content = `
      <div style="min-height: 20px;"></div>
      <div class="email-original-content">
        ${originalContent}
      </div>
    `;
    return { subject, content };
  }
  
  // Create formatted content for forwarded email
  const content = `
    <div style="min-height: 20px;">
    <div style="border-top: 1px solid #ccc; margin-top: 10px; padding-top: 10px;">
      <div style="font-family: Arial, sans-serif; color: #333;">
        <div style="margin-bottom: 15px;">
          <div>---------- Forwarded message ---------</div>
          <div><b>From:</b> ${fromString}</div>
          <div><b>Date:</b> ${dateString}</div>
          <div><b>Subject:</b> ${email.subject || ''}</div>
          <div><b>To:</b> ${toString}</div>
        </div>
        <div class="email-original-content">
          ${originalContent}
        </div>
      </div>
    </div>
    </div>
  `;
  
  return { subject, content };
}

/**
 * Format an email for reply or reply-all - CENTRAL IMPLEMENTATION
 * All other formatting functions should be deprecated in favor of this one
 */
export function formatReplyEmail(email: EmailMessage, type: 'reply' | 'reply-all'): {
  to: string;
  cc?: string;
  subject: string;
  content: string;
} {
  // Format subject with Re: prefix if needed
  const subjectBase = email.subject || '(No subject)';
  const subject = subjectBase.match(/^Re:/i) 
    ? subjectBase 
    : `Re: ${subjectBase}`;
  
  // Get sender information for quote header
  const sender = email.from[0];
  const fromText = sender?.name 
    ? `${sender.name} <${sender.address}>`
    : sender?.address || 'Unknown sender';
  
  // Format date for quote header
  const date = typeof email.date === 'string' ? new Date(email.date) : email.date;
  const formattedDate = date.toLocaleString('en-US', {
    weekday: 'short',
    year: 'numeric',
    month: 'short',
    day: 'numeric',
    hour: '2-digit', 
    minute: '2-digit'
  });
  
  // Create quote header
  const quoteHeader = `<div style="font-weight: 400; color: #555; margin: 20px 0 8px 0; font-size: 13px;">On ${formattedDate}, ${fromText} wrote:</div>`;
  
  // Get and sanitize original content (sanitization preserves content direction)
  let originalContent = '';
  if (email.content && typeof email.content === 'object') {
    const contentObj = email.content as EmailContent;
    originalContent = contentObj.html || contentObj.text || '';
  } else if (typeof email.content === 'string') {
    originalContent = email.content;
  } else {
    originalContent = email.html || email.text || '';
  }
  
  const quotedContent = sanitizeHtml(originalContent);
  
  // Format recipients
  let to = formatEmailAddresses(email.from || []);
  let cc = '';
  
  if (type === 'reply-all') {
    // For reply-all, add all original recipients to CC
    const allRecipients = [
      ...(email.to || []),
      ...(email.cc || [])
    ];
    
    cc = formatEmailAddresses(allRecipients);
  }
  
  // Format content for reply with improved styling
  const content = `
    <div style="min-height: 20px;"></div>
    <div class="reply-body" style="font-family: Arial, sans-serif; line-height: 1.5;">
      ${quoteHeader}
      <blockquote style="margin: 0; padding: 10px 0 10px 15px; border-left: 2px solid #ddd; color: #505050; background-color: #f9f9f9; border-radius: 4px;">
        <div class="quoted-content" style="font-size: 13px;">
          ${quotedContent}
        </div>
      </blockquote>
    </div>
  `;
  
  return {
    to,
    cc: cc || undefined,
    subject,
    content
  };
}

/**
 * COMPATIBILITY LAYER: For backward compatibility with the old email-formatter.ts
 * These functions map to our new implementation but preserve the old interface
 */
export function formatEmailForReplyOrForward(
  email: EmailMessage, 
  type: 'reply' | 'reply-all' | 'forward'
): {
  to: string;
  cc?: string;
  subject: string;
  body: string;
} {
  if (type === 'forward') {
    const { subject, content } = formatForwardedEmail(email);
    return {
      to: '',
      subject,
      body: content
    };
  } else {
    const { to, cc, subject, content } = formatReplyEmail(email, type as 'reply' | 'reply-all');
    return {
      to,
      cc,
      subject,
      body: content
    };
  }
}

/**
 * Decode compose content from MIME format to HTML and text
 */
export async function decodeComposeContent(content: string): Promise<{
  html: string | null;
  text: string | null;
}> {
  if (!content.trim()) {
    return { html: null, text: null };
  }

  try {
    const response = await fetch('/api/parse-email', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email: content }),
    });

    if (!response.ok) {
      throw new Error('Failed to parse email');
    }

    const parsed = await response.json();
    
    // Apply LTR sanitization to the parsed content
    return {
      html: parsed.html ? sanitizeHtml(parsed.html) : null,
      text: parsed.text || null
    };
  } catch (error) {
    console.error('Error parsing email content:', error);
    // Fallback to basic content handling with sanitization
    return {
      html: sanitizeHtml(content),
      text: content
    };
  }
}

/**
 * Encode compose content to MIME format for sending
 */
export function encodeComposeContent(content: string): string {
  if (!content.trim()) {
    throw new Error('Email content is empty');
  }

  // Create MIME headers
  const mimeHeaders = {
    'MIME-Version': '1.0',
    'Content-Type': 'text/html; charset="utf-8"',
    'Content-Transfer-Encoding': 'quoted-printable'
  };

  // Combine headers and content
  return Object.entries(mimeHeaders)
    .map(([key, value]) => `${key}: ${value}`)
    .join('\n') + '\n\n' + content;
}

// Legacy email formatter functions - renamed to avoid conflicts
export function formatReplyEmailLegacy(email: any): string {
  const originalSender = email.sender?.name || email.sender?.email || 'Unknown Sender';
  const originalDate = formatDateRelative(new Date(email.date));
  
  // Use our own sanitizeHtml function consistently
  const sanitizedBody = sanitizeHtml(email.content || '');
  
  return `
<p></p>
<p>On ${originalDate}, ${originalSender} wrote:</p>
<blockquote class="quoted-content">
  ${sanitizedBody}
</blockquote>
  `.trim();
}

export function formatForwardedEmailLegacy(email: any): string {
  const originalSender = email.sender?.name || email.sender?.email || 'Unknown Sender';
  const originalRecipients = email.to?.map((recipient: any) => 
    recipient.name || recipient.email
  ).join(', ') || 'Unknown Recipients';
  const originalDate = formatDateRelative(new Date(email.date));
  const originalSubject = email.subject || 'No Subject';
  
  // Use our own sanitizeHtml function consistently
  const sanitizedBody = sanitizeHtml(email.content || '');
  
  return `
<p></p>
<p>---------- Forwarded message ---------</p>
<p><strong>From:</strong> ${originalSender}</p>
<p><strong>Date:</strong> ${originalDate}</p>
<p><strong>Subject:</strong> ${originalSubject}</p>
<p><strong>To:</strong> ${originalRecipients}</p>
<br>
<div class="email-original-content">
  ${sanitizedBody}
</div>
  `.trim();
}

export function formatReplyToAllEmail(email: any): string {
  // For reply all, we use the same format as regular reply
  return formatReplyEmailLegacy(email);
}

// Utility function to get the reply subject line
export function getReplySubject(subject: string): string {
  return subject.startsWith('Re:') ? subject : `Re: ${subject}`;
}

// Utility function to get the forward subject line
export function getForwardSubject(subject: string): string {
  return subject.startsWith('Fwd:') ? subject : `Fwd: ${subject}`;
}