// In src/background.js
const solidPodCache = new Map();

chrome.webRequest.onHeadersReceived.addListener(
  (details) => {
    const headers = details.responseHeaders;

    // Check for Solid-specific headers
    const isSolid = headers.some(h =>
      h.name.toLowerCase() === 'wac-allow' ||        // Web Access Control
      h.name.toLowerCase() === 'updates-via' ||      // WebSocket updates
      (h.name.toLowerCase() === 'link' &&
       h.value.includes('ldp#Resource')) ||          // Linked Data Platform
      (h.name.toLowerCase() === 'x-powered-by' &&
       h.value.includes('JavaScriptSolidServer'))    // JSS-specific
    );

    if (isSolid) {
      const origin = new URL(details.url).origin;
      solidPodCache.set(origin, {
        detected: Date.now(),
        headers: headers.filter(h => h.name.toLowerCase().includes('solid'))
      });

      // Notify content script
      chrome.tabs.sendMessage(details.tabId, {
        type: 'SOLID_POD_DETECTED',
        url: details.url,
        headers: headers
      });
    }
  },
  { urls: ["<all_urls>"] },
  ["responseHeaders"]
);

// Message handler for cache queries
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.type === 'CHECK_SOLID_CACHE') {
    const origin = new URL(message.url).origin;
    sendResponse(solidPodCache.get(origin));
  }
});

// In content script
async function checkWellKnownSolid(url) {
  const origin = new URL(url).origin;

  try {
    const response = await fetch(`${origin}/.well-known/solid`);
    if (response.ok) {
      const config = await response.json();
      // Config contains: storage, oidcIssuer, etc.
      return config;
    }
  } catch (e) {
    console.log('[Podkey] No .well-known/solid found');
    return null;
  }
}

// User-maintained list in chrome.storage
const DEFAULT_POD_PROVIDERS = [
  'solidcommunity.net',
  'solidweb.org',
  'inrupt.net',
  'pod.inrupt.com',
  'localhost:8080'
];

async function isKnownPodProvider(url) {
  const { podkey_known_providers = DEFAULT_POD_PROVIDERS } =
    await chrome.storage.local.get(['podkey_known_providers']);

  const hostname = new URL(url).hostname;
  return podkey_known_providers.some(provider =>
    hostname.includes(provider)
  );
}

async function isSolidPod(url) {
  // 1. Check cache from webRequest (instant)
  const cached = await chrome.runtime.sendMessage({
    type: 'CHECK_SOLID_CACHE',
    url
  });
  if (cached) return cached;

  // 2. Check known providers (fast)
  if (await isKnownPodProvider(url)) return { detected: true, source: 'allowlist' };

  // 3. Check well-known (definitive but slower)
  const wellKnown = await checkWellKnownSolid(url);
  if (wellKnown) return { detected: true, source: 'well-known', config: wellKnown };

  // 4. Content detection (fallback)
  const hasDataBrowser = document.querySelector('script[src*="mashlib"]') ||
                        document.querySelector('script[src*="solid-ui"]');
  if (hasDataBrowser) return { detected: true, source: 'content' };

  return null;
}

// src/content-markdown.js
async function isMarkdownFile(url) {
  // Check URL extension
  if (url.endsWith('.md') || url.endsWith('.markdown')) {
    return true;
  }

  // Check Content-Type header
  const contentType = document.contentType;
  if (contentType?.includes('text/markdown')) {
    return true;
  }

  // Check for pre-rendered markdown (some servers render to HTML)
  const preElement = document.querySelector('pre');
  if (preElement && preElement.textContent.match(/^#\s+.+/m)) {
    return true;
  }

  return false;
}

// src/content-markdown.js
async function injectMarkdownEditor() {
  const isSolid = await isSolidPod(window.location.href);
  if (!isSolid) return;

  const isMarkdown = await isMarkdownFile(window.location.href);
  if (!isMarkdown) return;

  // Fetch current content
  const response = await fetch(window.location.href);
  const content = await response.text();

  // Replace page with editor
  document.body.innerHTML = '';
  document.body.className = 'podkey-markdown-editor';

  const editorContainer = document.createElement('div');
  editorContainer.id = 'podkey-editor-container';
  editorContainer.innerHTML = `
    <div id="podkey-toolbar">
      <div class="toolbar-left">
        <span class="file-name">${getFileName(window.location.href)}</span>
        <span class="pod-indicator">🔒 Solid Pod</span>
      </div>
      <div class="toolbar-right">
        <button id="podkey-preview-toggle" class="toolbar-btn">
          👁️ Preview
        </button>
        <button id="podkey-save" class="toolbar-btn primary">
          💾 Save
        </button>
      </div>
    </div>

    <div id="podkey-editor-wrapper">
      <textarea id="podkey-markdown-editor" spellcheck="false">${escapeHtml(content)}</textarea>
      <div id="podkey-preview-pane" style="display: none;"></div>
    </div>

    <div id="podkey-status-bar">
      <span id="podkey-status">Ready</span>
      <span id="podkey-word-count"></span>
    </div>
  `;

  document.body.appendChild(editorContainer);

  // Initialize editor
  const editor = document.getElementById('podkey-markdown-editor');
  const preview = document.getElementById('podkey-preview-pane');
  const saveBtn = document.getElementById('podkey-save');
  const previewToggle = document.getElementById('podkey-preview-toggle');
  const status = document.getElementById('podkey-status');

  let previewMode = false;

  // Live preview toggle
  previewToggle.addEventListener('click', () => {
    previewMode = !previewMode;
    if (previewMode) {
      editor.style.display = 'none';
      preview.style.display = 'block';
      preview.innerHTML = renderMarkdown(editor.value);
      previewToggle.textContent = '✏️ Edit';
    } else {
      editor.style.display = 'block';
      preview.style.display = 'none';
      previewToggle.textContent = '👁️ Preview';
    }
  });

  // Auto-update preview
  let previewTimeout;
  editor.addEventListener('input', () => {
    clearTimeout(previewTimeout);
    previewTimeout = setTimeout(() => {
      if (previewMode) {
        preview.innerHTML = renderMarkdown(editor.value);
      }
      updateWordCount(editor.value);
    }, 300);
  });

  // Save functionality
  saveBtn.addEventListener('click', async () => {
    try {
      saveBtn.disabled = true;
      saveBtn.textContent = '💾 Saving...';
      status.textContent = 'Signing request...';

      // Create NIP-98 auth event
      const authEvent = {
        kind: 27235, // Solid auth event
        created_at: Math.floor(Date.now() / 1000),
        tags: [
          ['u', window.location.href],
          ['method', 'PUT']
        ],
        content: ''
      };

      // Sign with Nostr key
      const signedEvent = await window.nostr.signEvent(authEvent);

      status.textContent = 'Uploading...';

      // PUT to Solid pod
      const putResponse = await fetch(window.location.href, {
        method: 'PUT',
        headers: {
          'Authorization': `Nostr ${btoa(JSON.stringify(signedEvent))}`,
          'Content-Type': 'text/markdown'
        },
        body: editor.value
      });

      if (putResponse.ok) {
        status.textContent = '✅ Saved successfully';
        saveBtn.classList.add('success');
        setTimeout(() => {
          saveBtn.classList.remove('success');
          status.textContent = 'Ready';
        }, 2000);
      } else {
        throw new Error(`Save failed: ${putResponse.status} ${putResponse.statusText}`);
      }
    } catch (error) {
      console.error('[Podkey] Save error:', error);
      status.textContent = '❌ Save failed: ' + error.message;
    } finally {
      saveBtn.disabled = false;
      saveBtn.textContent = '💾 Save';
    }
  });

  // Keyboard shortcuts
  editor.addEventListener('keydown', (e) => {
    // Ctrl+S / Cmd+S to save
    if ((e.ctrlKey || e.metaKey) && e.key === 's') {
      e.preventDefault();
      saveBtn.click();
    }

    // Ctrl+P / Cmd+P to toggle preview
    if ((e.ctrlKey || e.metaKey) && e.key === 'p') {
      e.preventDefault();
      previewToggle.click();
    }
  });

  // Initial word count
  updateWordCount(content);
}

function renderMarkdown(text) {
  // Use marked.js or similar library
  // For now, basic rendering:
  return text
    .replace(/^### (.*$)/gim, '<h3>$1</h3>')
    .replace(/^## (.*$)/gim, '<h2>$1</h2>')
    .replace(/^# (.*$)/gim, '<h1>$1</h1>')
    .replace(/\*\*(.*)\*\*/gim, '<strong>$1</strong>')
    .replace(/\*(.*)\*/gim, '<em>$1</em>')
    .replace(/\n/g, '<br>');
}

function updateWordCount(text) {
  const words = text.trim().split(/\s+/).length;
  const chars = text.length;
  document.getElementById('podkey-word-count').textContent =
    `${words} words · ${chars} characters`;
}

function getFileName(url) {
  return url.split('/').pop() || 'document.md';
}

function escapeHtml(text) {
  const div = document.createElement('div');
  div.textContent = text;
  return div.innerHTML;
}

// Initialize when page loads
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', injectMarkdownEditor);
} else {
  injectMarkdownEditor();
}

// Markdown Editor Settings
{
  enabled: true,
  autoInject: true,           // Auto-inject on .md files
  showPreview: false,         // Start in preview mode
  theme: 'light',             // light | dark
  fontSize: 14,               // Editor font size
  autoSave: false,            // Auto-save on change (with debounce)
  autoSaveDelay: 3000,        // ms
  keyboardShortcuts: true
}