// packages/shared/src/types/api.ts
export interface Task {
  id: string;
  title: string;
  status: 'open' | 'in-progress' | 'done';
  createdAt: string;
  updatedAt: string;
}

export interface ApiResponse<T> {
  data: T;
  error?: string;
  pagination?: {
    page: number;
    totalPages: number;
  };
}

// packages/extension/src/background/services/api-client.ts
import type { Task, ApiResponse } from '@myproject/shared/types/api';

async function fetchTasks(): Promise<Task[]> {
  const response = await fetch('https://api.myproject.com/tasks');
  const result: ApiResponse<Task[]> = await response.json();
  return result.data;
}

// src/shared/message-types.ts

// Define all possible messages as a discriminated union
export type ExtensionMessage =
  | { action: 'GET_TASKS'; payload?: never }
  | { action: 'CREATE_TASK'; payload: { title: string; status: string } }
  | { action: 'DELETE_TASK'; payload: { id: string } }
  | { action: 'GET_SETTINGS'; payload?: never }
  | { action: 'UPDATE_SETTINGS'; payload: Partial<Settings> };

// Define response types mapped to each action
export type MessageResponseMap = {
  GET_TASKS: Task[];
  CREATE_TASK: Task;
  DELETE_TASK: { success: boolean };
  GET_SETTINGS: Settings;
  UPDATE_SETTINGS: Settings;
};

export interface Task {
  id: string;
  title: string;
  status: string;
}

export interface Settings {
  theme: 'light' | 'dark';
  notifications: boolean;
  syncEnabled: boolean;
}

// src/shared/messaging.ts
import type { ExtensionMessage, MessageResponseMap } from './message-types';

export function sendMessage<T extends ExtensionMessage>(
  message: T
): Promise<MessageResponseMap[T['action']]> {
  return chrome.runtime.sendMessage(message);
}

// Usage -- fully type-checked
const tasks = await sendMessage({ action: 'GET_TASKS' });
// tasks is typed as Task[]

const newTask = await sendMessage({
  action: 'CREATE_TASK',
  payload: { title: 'Write docs', status: 'open' }
});
// newTask is typed as Task

// src/shared/storage-types.ts

export interface StorageSchema {
  tasks: Task[];
  settings: Settings;
  lastSync: number;
  userToken: string;
}

// Type-safe wrapper around chrome.storage
export async function getStorage<K extends keyof StorageSchema>(
  key: K
): Promise<StorageSchema[K] | undefined> {
  const result = await chrome.storage.local.get(key);
  return result[key];
}

export async function setStorage<K extends keyof StorageSchema>(
  key: K,
  value: StorageSchema[K]
): Promise<void> {
  await chrome.storage.local.set({ [key]: value });
}

// This function is untestable outside Chrome
async function saveBookmark(url: string, title: string) {
  const existing = await chrome.bookmarks.search({ url });
  if (existing.length > 0) {
    return existing[0];
  }
  return chrome.bookmarks.create({ url, title });
}

// src/shared/chrome-api.ts

export interface BookmarkApi {
  search(query: chrome.bookmarks.SearchQuery): Promise<chrome.bookmarks.BookmarkTreeNode[]>;
  create(bookmark: chrome.bookmarks.CreateDetails): Promise<chrome.bookmarks.BookmarkTreeNode>;
}

export interface StorageApi {
  get(keys: string | string[]): Promise<Record<string, unknown>>;
  set(items: Record<string, unknown>): Promise<void>;
}

export interface ChromeApi {
  bookmarks: BookmarkApi;
  storage: StorageApi;
}

// Production implementation
export const chromeApi: ChromeApi = {
  bookmarks: {
    search: (query) => chrome.bookmarks.search(query),
    create: (details) => chrome.bookmarks.create(details),
  },
  storage: {
    get: (keys) => chrome.storage.local.get(keys),
    set: (items) => chrome.storage.local.set(items),
  },
};

// src/features/bookmarks/bookmarkService.ts
import type { ChromeApi } from '../../shared/chrome-api';

export function createBookmarkService(api: ChromeApi) {
  return {
    async saveBookmark(url: string, title: string) {
      const existing = await api.bookmarks.search({ url });
      if (existing.length > 0) {
        return existing[0];
      }
      return api.bookmarks.create({ url, title });
    },

    async getAll() {
      const result = await api.storage.get('savedBookmarks');
      return (result.savedBookmarks as string[]) || [];
    }
  };
}

// tests/bookmarkService.test.ts
import { createBookmarkService } from '../src/features/bookmarks/bookmarkService';
import type { ChromeApi } from '../src/shared/chrome-api';

function createMockApi(): ChromeApi {
  const storage = new Map<string, unknown>();

  return {
    bookmarks: {
      search: async () => [],
      create: async (details) => ({
        id: '1',
        title: details.title || '',
        url: details.url,
      }),
    },
    storage: {
      get: async (keys) => {
        const result: Record<string, unknown> = {};
        const keyList = Array.isArray(keys) ? keys : [keys];
        for (const key of keyList) {
          if (storage.has(key)) result[key] = storage.get(key);
        }
        return result;
      },
      set: async (items) => {
        for (const [key, value] of Object.entries(items)) {
          storage.set(key, value);
        }
      },
    },
  };
}

test('saveBookmark creates new bookmark when none exists', async () => {
  const api = createMockApi();
  const service = createBookmarkService(api);

  const result = await service.saveBookmark('https://example.com', 'Example');
  expect(result.url).toBe('https://example.com');
  expect(result.title).toBe('Example');
});

// src/shared/event-bus.ts

type EventHandler<T = unknown> = (data: T) => void | Promise<void>;

export class EventBus {
  private handlers = new Map<string, Set<EventHandler>>();

  on<T>(event: string, handler: EventHandler<T>): () => void {
    if (!this.handlers.has(event)) {
      this.handlers.set(event, new Set());
    }
    this.handlers.get(event)!.add(handler as EventHandler);

    // Return unsubscribe function
    return () => {
      this.handlers.get(event)?.delete(handler as EventHandler);
    };
  }

  async emit<T>(event: string, data: T): Promise<void> {
    const handlers = this.handlers.get(event);
    if (!handlers) return;

    const promises = Array.from(handlers).map((handler) => handler(data));
    await Promise.all(promises);
  }
}

// src/shared/cross-context-bus.ts

interface BusMessage {
  __bus_event: string;
  __bus_data: unknown;
}

function isBusMessage(msg: unknown): msg is BusMessage {
  return typeof msg === 'object' && msg !== null && '__bus_event' in msg;
}

export class CrossContextBus extends EventBus {
  constructor(private contextName: string) {
    super();
    this.listenForRemoteEvents();
  }

  private listenForRemoteEvents() {
    chrome.runtime.onMessage.addListener((msg, sender) => {
      if (isBusMessage(msg)) {
        // Call local handlers only -- do not re-broadcast
        super.emit(msg.__bus_event, msg.__bus_data);
      }
    });
  }

  // Override emit to also broadcast to other contexts
  async emit<T>(event: string, data: T): Promise<void> {
    // Handle locally
    await super.emit(event, data);

    // Broadcast to other contexts
    const message: BusMessage = {
      __bus_event: event,
      __bus_data: data,
    };

    // Send to service worker / other extension pages
    try {
      await chrome.runtime.sendMessage(message);
    } catch {
      // Other context may not be listening
    }
  }
}

// Usage in each context
const bus = new CrossContextBus('background');

bus.on('task:created', (task) => {
  console.log('New task created:', task);
});

bus.emit('task:created', { id: '1', title: 'New task' });

// src/background/bus-bridge.ts

export function setupBusBridge(bus: CrossContextBus) {
  // Forward select events to all content scripts
  const broadcastEvents = ['settings:updated', 'theme:changed'];

  for (const event of broadcastEvents) {
    bus.on(event, async (data) => {
      const tabs = await chrome.tabs.query({});
      for (const tab of tabs) {
        if (tab.id) {
          try {
            await chrome.tabs.sendMessage(tab.id, {
              __bus_event: event,
              __bus_data: data,
            });
          } catch {
            // Content script not loaded in this tab
          }
        }
      }
    });
  }
}

// src/shared/plugin-types.ts

export interface ExtensionPlugin {
  /** Unique identifier for this plugin */
  id: string;

  /** Human-readable name */
  name: string;

  /** Called when the plugin is loaded */
  initialize(context: PluginContext): Promise<void>;

  /** Called when the plugin is unloaded */
  destroy(): Promise<void>;
}

export interface PluginContext {
  /** Access to the event bus */
  bus: EventBus;

  /** Scoped storage for this plugin */
  storage: {
    get(key: string): Promise<unknown>;
    set(key: string, value: unknown): Promise<void>;
  };

  /** Register a content script handler */
  registerContentHandler(pattern: string, handler: () => void): void;
}

// src/background/plugin-manager.ts

export class PluginManager {
  private plugins = new Map<string, ExtensionPlugin>();
  private contexts = new Map<string, PluginContext>();

  constructor(private bus: EventBus) {}

  async register(plugin: ExtensionPlugin): Promise<void> {
    if (this.plugins.has(plugin.id)) {
      throw new Error(`Plugin ${plugin.id} is already registered`);
    }

    const context = this.createContext(plugin.id);
    this.plugins.set(plugin.id, plugin);
    this.contexts.set(plugin.id, context);

    await plugin.initialize(context);
    console.log(`[PluginManager] Loaded plugin: ${plugin.name}`);
  }

  async unregister(pluginId: string): Promise<void> {
    const plugin = this.plugins.get(pluginId);
    if (plugin) {
      await plugin.destroy();
      this.plugins.delete(pluginId);
      this.contexts.delete(pluginId);
    }
  }

  private createContext(pluginId: string): PluginContext {
    const storagePrefix = `plugin_${pluginId}_`;

    return {
      bus: this.bus,
      storage: {
        async get(key: string) {
          const result = await chrome.storage.local.get(storagePrefix + key);
          return result[storagePrefix + key];
        },
        async set(key: string, value: unknown) {
          await chrome.storage.local.set({ [storagePrefix + key]: value });
        },
      },
      registerContentHandler(pattern, handler) {
        // Store handler registration for dynamic content script injection
        console.log(`[Plugin:${pluginId}] Registered handler for ${pattern}`);
      },
    };
  }

  getLoadedPlugins(): string[] {
    return Array.from(this.plugins.keys());
  }
}

// src/plugins/word-counter.ts
import type { ExtensionPlugin, PluginContext } from '../shared/plugin-types';

export const wordCounterPlugin: ExtensionPlugin = {
  id: 'word-counter',
  name: 'Word Counter',

  async initialize(context: PluginContext) {
    context.bus.on('page:loaded', async (data: { tabId: number; url: string }) => {
      // React to page loads
      const count = await context.storage.get('totalWords') as number || 0;
      await context.storage.set('totalWords', count);
    });

    context.registerContentHandler('https://*/*', () => {
      // Content script logic for this plugin
    });
  },

  async destroy() {
    // Clean up any resources
  },
};

// src/background/index.js
import { PluginManager } from './plugin-manager';
import { wordCounterPlugin } from '../plugins/word-counter';
import { readingModePlugin } from '../plugins/reading-mode';

const bus = new EventBus();
const pluginManager = new PluginManager(bus);

// Register all plugins
await pluginManager.register(wordCounterPlugin);
await pluginManager.register(readingModePlugin);

// Allow users to enable/disable plugins via settings
chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
  if (msg.action === 'togglePlugin') {
    const { pluginId, enabled } = msg.payload;
    if (enabled) {
      // Re-register the plugin
    } else {
      pluginManager.unregister(pluginId);
    }
    sendResponse({ success: true });
  }
  return true;
});