import MimeType from 'whatwg-mimetype';
import type { EditorProps } from '../components/core/Editor/Editor';

export function languageFromContentType(
  contentType: string | null,
  content: string | null = null,
): EditorProps['language'] {
  const justContentType = contentType?.split(';')[0] ?? contentType ?? '';
  if (justContentType.includes('json')) {
    return 'json';
  }
  if (justContentType.includes('xml')) {
    return 'xml';
  }
  if (justContentType.includes('html')) {
    const detected = languageFromContent(content);
    if (detected === 'xml') {
      // If it's detected as XML, but is already HTML, don't change it
      return 'html';
    }
    return detected;
  }
  if (justContentType.includes('javascript')) {
    // Sometimes `application/javascript` returns JSON, so try detecting that
    return languageFromContent(content, 'javascript');
  }
  if (justContentType.includes('markdown')) {
    return 'markdown';
  }

  return languageFromContent(content, 'text');
}

export function languageFromContent(
  content: string | null,
  fallback?: EditorProps['language'],
): EditorProps['language'] {
  if (content == null) return 'text';

  const firstBytes = content.slice(0, 20).trim();

  if (firstBytes.startsWith('{') || firstBytes.startsWith('[')) {
    return 'json';
  }
  if (
    firstBytes.toLowerCase().startsWith('<!doctype') ||
    firstBytes.toLowerCase().startsWith('<html')
  ) {
    return 'html';
  }
  if (firstBytes.startsWith('<')) {
    return 'xml';
  }

  return fallback;
}

export function isJSON(content: string | null | undefined): boolean {
  if (typeof content !== 'string') return false;

  try {
    JSON.parse(content);
    return true;
  } catch {
    return false;
  }
}

export function isProbablyTextContentType(contentType: string | null): boolean {
  if (contentType == null) return false;

  const mimeType = getMimeTypeFromContentType(contentType).essence;
  const normalized = mimeType.toLowerCase();

  // Check if it starts with "text/"
  if (normalized.startsWith('text/')) {
    return true;
  }

  // Common text mimetypes and suffixes
  return [
    'application/json',
    'application/xml',
    'application/javascript',
    'application/yaml',
    '+json',
    '+xml',
    '+yaml',
    '+text',
  ].some((textType) => normalized === textType || normalized.endsWith(textType));
}

export function getMimeTypeFromContentType(contentType: string): MimeType {
  try {
    return new MimeType(contentType);
  } catch {
    return new MimeType('text/plain');
  }
}