// LinkdingSync Background Service Worker
// Handles synchronization logic, bookmark management, and API calls

'use strict';

// Direct browser.storage.local API (no prefix in service worker)
const storage = {
  get(keys) {
    return browser.storage.local.get(keys);
  },
  
  set(items) {
    return browser.storage.local.set(items);
  },
  
  clear() {
    return browser.storage.local.clear();
  }
};

// Direct browser.bookmarks API (no prefix in service worker)
const bookmarks = {
  getTree() {
    return browser.bookmarks.getTree();
  },
  
  get(id) {
    return browser.bookmarks.get(id);
  },
  
  onCreated(handler) {
    browser.bookmarks.onCreated.addListener(handler);
  },
  
  onChanged(handler) {
    browser.bookmarks.onChanged.addListener(handler);
  },
  
  onRemoved(handler) {
    browser.bookmarks.onRemoved.addListener(handler);
  }
};

// Global API Client module
class ApiClient {
  constructor(serverUrl, apiKey) {
    this.serverUrl = serverUrl.endsWith('/') ? serverUrl : serverUrl + '/';
    this.apiToken = apiKey;
    this.baseURL = this.serverUrl + 'api';
  }

  async getAuthHeaders() {
    return {
      'Authorization': `Token ${this.apiToken}`
    };
  }

  async getBundles() {
    try {
      const response = await fetch(`${this.baseURL}bundles/?limit=100`, {
        headers: await this.getAuthHeaders()
      });
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Get bundles error:', error);
      return { results: [], count: 0 };
    }
  }

  async getBundle(bundleTag) {
    try {
      // Query bookmarks with this tag
      const response = await fetch(`${this.baseURL}bookmarks/?limit=1&any=${encodeURIComponent(bundleTag)}`, {
        headers: await this.getAuthHeaders()
      });
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      const data = await response.json();
      return data;
    } catch (error) {
      return { results: [], count: 0 };
    }
  }

  async getBundleDetails(bundleId) {
    try {
      const response = await fetch(`${this.baseURL}bundles/${bundleId}/`, {
        headers: await this.getAuthHeaders()
      });
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      return null;
    }
  }

  async checkUrl(url) {
    try {
      const response = await fetch(`${this.baseURL}bookmarks/check/?url=${encodeURIComponent(url)}`, {
        headers: await this.getAuthHeaders()
      });
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      return { bookmark: null };
    }
  }

  async createBookmark(bookmarkData) {
    try {
      const response = await fetch(`${this.baseURL}bookmarks/`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          ...await this.getAuthHeaders()
        },
        body: JSON.stringify(bookmarkData)
      });
      
      if (!response.ok) {
        const error = await response.text();
        throw new Error(`HTTP ${response.status}: ${response.statusText} - ${error}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Create bookmark error:', error);
      throw error;
    }
  }

  async updateBookmark(bookmarkId, bookmarkData) {
    try {
      const response = await fetch(`${this.baseURL}bookmarks/${bookmarkId}/`, {
        method: 'PUT',
        headers: {
          'Content-Type': 'application/json',
          ...await this.getAuthHeaders()
        },
        body: JSON.stringify(bookmarkData)
      });
      
      if (!response.ok) {
        const error = await response.text();
        throw new Error(`HTTP ${response.status}: ${response.statusText} - ${error}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Update bookmark error:', error);
      throw error;
    }
  }

  async deleteBookmark(bookmarkId) {
    try {
      const response = await fetch(`${this.baseURL}bookmarks/${bookmarkId}/`, {
        method: 'DELETE',
        headers: await this.getAuthHeaders()
      });
      
      if (!response.ok && response.status !== 404) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
    } catch (error) {
      console.error('Delete bookmark error:', error);
      throw error;
    }
  }

  async addBundle(bundleData) {
    try {
      const response = await fetch(`${this.baseURL}bundles/`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          ...await this.getAuthHeaders()
        },
        body: JSON.stringify(bundleData)
      });
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error('Add bundle error:', error);
      throw error;
    }
  }
};

// Global Store for state management
class Store {
  async get(keys) {
    try {
      const data = await storage.get(keys);
      return data;
    } catch (error) {
      console.error('Storage load error:', error);
      return {};
    }
  }

  async set(items) {
    try {
      await storage.set(items);
      return true;
    } catch (error) {
      console.error('Storage save error:', error);
      return false;
    }
  }
}

// Global Notes Manager for version handling
class NotesManager {
  static getHostname() {
    try {
      return window.location.hostname || navigator.deviceMemory || 'unknown';
    } catch (e) {
      return 'unknown';
    }
  }

  static getProfileName() {
    try {
      return navigator.userAgent.toLowerCase().match(/(firefox|chrome|edge|safari|opera)/i)?.[1] || 'browser';
    } catch (e) {
      return 'browser';
    }
  }

  static generateBundleTag(serverUrl) {
    const hostname = this.getHostname();
    const profile = this.getProfileName();
    const normalizedHost = hostname.replace(/\./g, '_').toLowerCase();
    
    // If bundleTag is configured, use it
    if (serverUrl && serverUrl.bundleTag) {
      return serverUrl.bundleTag;
    }
    
    // Otherwise auto-generate from hostname/profile
    return `bundle_${normalizedHost}_${profile}_${Date.now().toString().slice(-4)}`;
  }

  static parseVersion(version) {
    const [major, minor] = version.split('.').map(Number);
    return { major, minor };
  }

  static parseNotes(noteString) {
    if (!noteString) {
      return null;
    }
    
    try {
      const parsed = JSON.parse(noteString);
      
      // Handle non-JSON notes (old bookmarks)
      if (typeof parsed === 'string') {
        return {
          version: '1.0',
          path: '',
          userNotes: parsed,
          autoTags: [],
          bundleTag: null,
          keyword: ''
        };
      }
      
      // Handle notes without version field (old structured format)
      if (!parsed.version) {
        return {
          version: '1.0',
          path: parsed.path || '',
          userNotes: parsed.userNotes || parsed.notes || parsed.description || '',
          autoTags: parsed.autoTags || [],
          bundleTag: parsed.bundleTag || null,
          keyword: parsed.keyword || ''
        };
      }
      
      // Handle version 1.x - basic fields only
      if (this.parseVersion(parsed.version).major < 2) {
        return {
          version: parsed.version,
          path: parsed.path || '',
          userNotes: parsed.userNotes || '',
          autoTags: parsed.autoTags || [],
          bundleTag: parsed.bundleTag || null,
          keyword: parsed.keyword || ''
        };
      }
      
      // Handle version 2.x and above
      return {
        version: parsed.version,
        path: parsed.path || '',
        userNotes: parsed.userNotes || '',
        autoTags: parsed.autoTags || [],
        bundleTag: parsed.bundleTag || null,
        keyword: parsed.keyword || '',
        ...parsed
      };
    } catch (e) {
      // Invalid JSON - treat as old notes
      return {
        version: '1.0',
        path: '',
        userNotes: noteString,
        autoTags: [],
        bundleTag: null,
        keyword: ''
      };
    }
  }

  static formatNotes(notesObject) {
    if (!notesObject) {
      return '';
    }
    
    return JSON.stringify(notesObject);
  }

  static createEmptyNotes(bundleTag) {
    return {
      version: '1.0',
      path: '',
      userNotes: '',
      autoTags: [],
      bundleTag: bundleTag,
      keyword: ''
    };
  }

  static shouldMigrate(notes) {
    // Should migrate if:
    // - notes is not a string (not JSON)
    // - notes doesn't have version field
    // - version is old (< 1.0)
    if (!notes) {
      return true;
    }
    
    if (typeof notes !== 'object') {
      return true;
    }
    
    const version = notes.version || '0.0';
    const current = this.parseVersion(version);
    const target = this.parseVersion('1.0');
    
    return current.major < target.major;
  }

  static migrateNotes(oldNotes, bundleTag) {
    return {
      version: '1.0',
      path: '',
      userNotes: typeof oldNotes === 'string' ? oldNotes : '',
      autoTags: [],
      bundleTag: bundleTag,
      keyword: ''
    };
  }

  static updateBundleTag(notes, bundleTag) {
    if (!notes) return notes;
    if (typeof notes !== 'object') return notes;
    
    const parsed = this.parseNotes(notes);
    
    // If this is our extension's notes (version 1.0 without bundleTag), update bundleTag
    if (!parsed.bundleTag) {
      return {
        ...parsed,
        bundleTag: bundleTag
      };
    }
    
    return notes;
  }
};

// Global utility functions
const Utils = {
  formatTimestamp(timestamp) {
    if (!timestamp) return 'Never';
    
    const date = new Date(timestamp);
    const options = {
      year: 'numeric',
      month: 'short',
      day: 'numeric',
      hour: '2-digit',
      minute: '2-digit',
      timeZoneName: 'short'
    };
    
    return date.toLocaleDateString('en-US', options);
  },

  getBookmarkPath(bookmark) {
    if (!bookmark.notes || typeof bookmark.notes !== 'string') {
      return '';
    }
    
    try {
      const notes = JSON.parse(bookmark.notes);
      return notes.path || '';
    } catch (e) {
      return '';
    }
  },

  extractTagsFromPath(path) {
    if (!path) return [];
    
    const folders = path.split('/').filter(f => f);
    return folders.map(folder => ({
      name: folder.trim()
    }));
  },

  async showNotification(message, type = 'info', duration = 4000) {
    const types = {
      info: { color: '#2196f3', icon: 'ℹ️' },
      success: { color: '#4caf50', icon: '✓' },
      warning: { color: '#ff9800', icon: '⚠️' },
      error: { color: '#f44336', icon: '✕' }
    };
    
    const style = types[type] || types.info;
    
    // Remove existing notifications
    const existing = document.getElementById('notification-area');
    if (existing) existing.remove();
    
    // Create notification
    const notification = document.createElement('div');
    notification.id = 'notification-area';
    notification.style.cssText = `
      position: fixed;
      bottom: 20px;
      left: 50%;
      transform: translateX(-50%);
      background: ${style.color};
      color: white;
      padding: 12px 20px;
      border-radius: 8px;
      box-shadow: 0 4px 12px rgba(0,0,0,0.2);
      z-index: 9999;
      font-size: 13px;
      max-width: 90vw;
      text-align: center;
    `;
    notification.textContent = `${style.icon} ${message}`;
    document.body.appendChild(notification);
    
    // Auto-remove after duration
    if (duration > 0) {
      setTimeout(() => {
        if (notification.parentNode) {
          notification.remove();
        }
      }, duration);
    }
  }
};

// Global Sync Manager
class SyncManager {
  constructor() {
    this.api = null;
    this.store = new Store();
    this.config = null;
    this.lastSyncTime = null;
    this.bundleTag = null;
    this.bundleId = null;
  }

  async init(config) {
    this.config = config;
    this.api = new ApiClient(config.serverUrl, config.apiKey);
    
    // Auto-generate bundle tag if not set
    if (!config.bundleTag) {
      this.bundleTag = NotesManager.generateBundleTag(config.serverUrl);
      await this.store.set({ bundleTag: this.bundleTag });
    } else {
      this.bundleTag = config.bundleTag;
    }
    
    this.lastSyncTime = Date.now();
    await this.store.set({ lastSyncTime: this.lastSyncTime });
    
    // Ensure bundle exists
    await this.ensureBundle();
  }

  async ensureBundle() {
    try {
      // Get existing bundle
      let bundleData = await this.getBundleDetails(this.bundleId);
      
      if (!bundleData) {
        // Bundle doesn't exist, create it
        bundleData = await this.createBundle(this.bundleTag);
      }
      
      // Save bundle info
      await this.store.set({ 
        bundleId: bundleData.id,
        bundleName: bundleData.name || this.bundleTag,
        bundleTags: bundleData.all_tags || ''
      });
      
      return bundleData;
    } catch (error) {
      console.error('Ensure bundle error:', error);
      return null;
    }
  }

  async createBundle(bundleTag) {
    // Create new bundle with required_tags set to our bundle tag
    const bundleData = {
      name: bundleTag,
      search: '',
      any_tags: '',
      all_tags: bundleTag,
      excluded_tags: ''
    };
    
    return await this.api.addBundle(bundleData);
  }

  async getBundle(bundleTag) {
    // First check if bundle exists
    let bundleData = await this.getBundleDetails(this.bundleId);
    
    if (bundleData) {
      // Bundle exists, get bookmarks with this tag
      // Use pagination to handle more than 1000 bookmarks
      const allBookmarks = [];
      let hasMore = true;
      let offset = 0;
      const pageSize = 100;
      
      while (hasMore) {
        const response = await fetch(
          `${this.config.serverUrl}api/bookmarks/?limit=${pageSize}&all=${encodeURIComponent(bundleData.all_tags || '')}&offset=${offset}`,
          { headers: await this.api.getAuthHeaders() }
        );
        
        if (!response.ok) {
          break;
        }
        
        const data = await response.json();
        allBookmarks.push(...(data.results || []));
        
        if (data.results?.length < pageSize) {
          hasMore = false;
        } else {
          offset += pageSize;
        }
      }
      
      return {
        bundleId: bundleData.id,
        bundleTag: bundleData.name || bundleTag,
        count: allBookmarks.length,
        results: allBookmarks
      };
    }
    
    // Bundle doesn't exist yet, create it
    bundleData = await this.createBundle(bundleTag);
    
    // Create empty bundle
    return { results: [], count: 0, bundleId: bundleData.id };
  }

  async checkBookmark(url) {
    if (!url) return null;
    
    try {
      const result = await this.api.checkUrl(url);
      return result.bookmark;
    } catch (error) {
      console.error('Check bookmark error:', error);
      return null;
    }
  }

  async syncBookmark(bookmarkData, folder) {
    // Get bundle tag from config or auto-generated
    const config = await this.store.get();
    const bundleTag = config.bundleTag || this.bundleTag;
    
    if (!bundleTag) {
      throw new Error('No bundle tag configured');
    }
    
    // Check if bookmark exists
    const existing = await this.checkBookmark(bookmarkData.url);
    
    if (existing) {
      // Bookmark exists - update it
      const existingNotes = this.parseAndMigrateNotes(existing.notes, bundleTag);
      
      // Get autoGenerateTags setting
      const autoGenerateTags = config.autoGenerateTags || false;
      
      // Merge Firefox tags to Linkding tags (only if autoGenerateTags is enabled)
      const mergedNotes = this.mergeNotes(existingNotes, bookmarkData.notes, bookmarkData.tags, autoGenerateTags);
      
      // Update bookmark
      const updated = await this.api.updateBookmark(existing.id, {
        title: bookmarkData.title || existing.title,
        description: bookmarkData.description || existing.description,
        notes: mergedNotes,
        // Use browser's keyword for consistent cross-browser sync
        keyword: bookmarkData.keyword || existing.keyword || ''
      });
      
      return updated;
    } else {
      // Create new bookmark with bundle tag
      const newNotes = NotesManager.createEmptyNotes(bundleTag);
      
      // Add folder path if provided
      if (folder) {
        newNotes.path = folder;
      }
      
      // Add user notes if provided
      if (bookmarkData.notes) {
        newNotes.userNotes = bookmarkData.notes;
      }
      
      // Add Firefox tags if provided AND autoGenerateTags is enabled
      if (bookmarkData.tags && autoGenerateTags) {
        newNotes.autoTags = bookmarkData.tags;
      }
      
      // Add keyword if provided
      if (bookmarkData.keyword) {
        newNotes.keyword = bookmarkData.keyword;
      }
      
      // Create new bookmark
      const newBookmark = {
        url: bookmarkData.url,
        title: bookmarkData.title,
        description: bookmarkData.description,
        notes: NotesManager.formatNotes(newNotes),
        unread: false,
        shared: false
      };
      
      return await this.api.createBookmark(newBookmark);
    }
  }

  parseAndMigrateNotes(noteString, bundleTag) {
    if (!noteString) {
      return NotesManager.createEmptyNotes(bundleTag);
    }
    
    const parsed = NotesManager.parseNotes(noteString);
    
    // Migrate if needed
    if (NotesManager.shouldMigrate(parsed)) {
      parsed = NotesManager.migrateNotes(parsed, bundleTag);
    }
    
    // Update bundle tag if this is our notes
    parsed = NotesManager.updateBundleTag(parsed, bundleTag);
    
    return parsed;
  }

  mergeNotes(notes1, notes2, tags = [], autoGenerateTags = false) {
    // Parse both notes
    const p1 = NotesManager.parseNotes(notes1);
    const p2 = NotesManager.parseNotes(notes2);
    
    // Combine tags (use Firefox tags if provided and autoGenerateTags is enabled)
    const combinedTags = autoGenerateTags && tags.length > 0 ? tags : (p2.autoTags || []);
    
    // Merge notes with Firefox keyword support
    return {
      version: Math.max(p1.version, p2.version),
      path: p1.path || p2.path || '',
      userNotes: p1.userNotes || p2.userNotes || '',
      autoTags: combinedTags,
      bundleTag: p1.bundleTag || p2.bundleTag,
      // Store Firefox keyword in notes for cross-browser sync
      keyword: p1.keyword || p2.keyword || ''
    };
  }

  async deleteBookmark(url) {
    const existing = await this.checkBookmark(url);
    
    if (!existing) {
      return { success: false, error: 'Bookmark not found' };
    }
    
    try {
      await this.api.deleteBookmark(existing.id);
      return { success: true };
    } catch (error) {
      console.error('Delete bookmark error:', error);
      return { success: false, error: error.message };
    }
  }

  async getBundleInfo() {
    const config = await this.store.get();
    
    if (!config.apiKey || !config.serverUrl) {
      return null;
    }
    
    try {
      const bundleInfo = await this.ensureBundle();
      
      if (!bundleInfo) {
        return null;
      }
      
      // Get bookmarks with this tag using "all" query param
      const response = await fetch(`${config.serverUrl}api/bookmarks/?limit=1000&all=${encodeURIComponent(bundleInfo.all_tags || '')}`, {
        headers: await this.api.getAuthHeaders()
      });
      
      if (response.ok) {
        const results = await response.json();
        return {
          bundleId: bundleInfo.id,
          bundleTag: bundleInfo.name || this.bundleTag,
          count: results.count || results.results?.length || 0,
          results: results.results || []
        };
      }
      
      return {
        bundleId: bundleInfo.id,
        bundleTag: bundleInfo.name || this.bundleTag,
        count: 0,
        results: []
      };
    } catch (error) {
      console.error('Get bundle info error:', error);
      return null;
    }
  }

  async syncAllBookmarks() {
    const config = await this.store.get();
    
    if (!config.apiKey || !config.serverUrl) {
      console.log('Not configured for sync');
      return;
    }
    
    try {
      await this.init(config);
      const bundleInfo = await this.getBundleInfo();
      
      if (!bundleInfo) {
        console.log('No bundle available');
        return;
      }
      
      // Fetch bookmarks from Linkding with bundle filter
      const linkdingBookmarks = await this.getBundle(bundleInfo.bundleTag);
      
      // Get browser bookmarks
      const browserBookmarks = await bookmarks.getTree();
      
      // Sync each bookmark
      for (const bookmark of browserBookmarks) {
        await this.syncBookmark(bookmark, '', this.config.syncMode);
      }
      
      this.lastSyncTime = Date.now();
      await this.store.set({ lastSyncTime: this.lastSyncTime });
      
      Utils.showNotification(`Synced ${linkdingBookmarks.count || 0} bookmarks`, 'success');
      
    } catch (error) {
      console.error('Sync all error:', error);
      Utils.showNotification('Sync failed: ' + error.message, 'error');
    }
  }
};

// Export for console access
window.LinkdingSync = {
  ApiClient: ApiClient,
  Store: Store,
  Utils: Utils,
  NotesManager: NotesManager,
  Manager: SyncManager
};

// Initialize when storage changes
browser.storage.onChanged.addListener((changes, area) => {
  if (area === 'local') {
    console.log('Configuration changed:', changes);
  }
});

// Listen for bookmark changes
browser.bookmarks.onCreated.addListener(async (bookmark) => {
  console.log('Bookmark created:', bookmark.id);
  
  const manager = new SyncManager();
  const config = await manager.store.get();
  if (config) {
    manager.syncBookmark(bookmark, '', config.syncMode);
  }
});

browser.bookmarks.onChanged.addListener(async (change, bookmarkId) => {
  console.log('Bookmark changed:', bookmarkId);
  
  const manager = new SyncManager();
  const bookmarkData = await browser.bookmarks.get(bookmarkId);
  if (bookmarkData && bookmarkData[0]) {
    const config = await manager.store.get();
    if (config) {
      manager.syncBookmark(bookmarkData[0], '', config.syncMode);
    }
  }
});

browser.bookmarks.onRemoved.addListener(async (removed, bookmarkId) => {
  console.log('Bookmark removed:', bookmarkId);
  
  const manager = new SyncManager();
  const config = await manager.store.get();
  if (config) {
    manager.deleteBookmark(removed.url);
  }
});

// Initialize
console.log('linkdingsync initialized');