import { linkTypeRegistry, LinkTypeHandler } from './parser/orgLinkTypes';

const myHandler: LinkTypeHandler = {
  type: 'jira',
  description: 'Link to Jira issues',

  // Pure resolution - no side effects
  resolve(path, context) {
    return {
      displayText: path,
      url: `https://jira.example.com/browse/${path}`,
      tooltip: `Open Jira issue ${path}`
    };
  },

  // Export for different backends
  export(path, description, backend, context) {
    const url = `https://jira.example.com/browse/${path}`;
    const text = description || path;

    switch (backend) {
      case 'html':
        return `<a href="${url}">${text}</a>`;
      case 'latex':
        return `\\href{${url}}{${text}}`;
      default:
        return text;
    }
  },

  // Optional: completion suggestions
  async complete(prefix, context) {
    return [
      { text: 'PROJ-123', label: 'PROJ-123', detail: 'Bug fix' }
    ];
  }
};

linkTypeRegistry.register(myHandler);

import { linkFollowRegistry, LinkFollowHandler } from './adapters/linkFollowAdapter';

const myFollowHandler: LinkFollowHandler = {
  type: 'jira',

  async follow(path, context) {
    await vscode.env.openExternal(
      vscode.Uri.parse(`https://jira.example.com/browse/${path}`)
    );
  }
};

linkFollowRegistry.register(myFollowHandler);

~/.scimax/exporters/
├── my-journal/
│   ├── manifest.json      # Configuration
│   ├── template.tex       # Handlebars template
│   └── partials/          # Optional partial templates
│       └── header.tex

{
  "id": "my-journal",
  "name": "My Journal Format",
  "description": "Custom journal article format",
  "parent": "latex",
  "outputFormat": "pdf",
  "template": "template.tex",
  "orgTemplate": "template.org",
  "keywords": {
    "JOURNAL": {
      "required": true,
      "description": "Target journal name"
    },
    "VOLUME": {
      "default": "1"
    }
  },
  "latexOptions": {
    "documentClass": "article",
    "packages": ["hyperref", "graphicx"]
  }
}

{
  "id": "cmu-memo",
  "template": "template.tex",
  "orgTemplate": "template.org"
}

{
  "scimax.export.latexClassExporters": {
    "cmu-memo": "cmu-memo",
    "cmu-ms-report": "cmu-ms-report"
  }
}

#+LATEX_CLASS: cmu-memo
#+TO: Selection Committee
#+FROM: John Kitchin
#+SUBJECT: Recommendation

#+LATEX_CLASS: cmu-memo
#+LATEX_HEADER: \usepackage{setspace}
#+LATEX_HEADER: \onehalfspacing

interface LanguageExecutor {
  /** Language names this executor handles (e.g., ['ruby', 'rb']) */
  languages: string[];

  /** Execute code and return result */
  execute(code: string, context: ExecutionContext): Promise<ExecutionResult>;

  /** Initialize a persistent session (optional) */
  initSession?(sessionName: string, context: ExecutionContext): Promise<void>;

  /** Close a session (optional) */
  closeSession?(sessionName: string): Promise<void>;

  /** Check if the runtime is available */
  isAvailable(): Promise<boolean>;
}

interface ExecutionContext {
  cwd?: string;                    // Working directory
  env?: Record<string, string>;    // Environment variables
  session?: string;                // Session name for persistence
  variables?: Record<string, unknown>; // From :var arguments
  timeout?: number;                // Execution timeout
}

interface ExecutionResult {
  success: boolean;
  stdout: string;
  stderr: string;
  executionTime: number;  // milliseconds
}

import { registerBabelExecutor, LanguageExecutor } from './adapters/babelExecutorAdapter';

const rubyExecutor: LanguageExecutor = {
  languages: ['ruby', 'rb'],

  async execute(code, context) {
    // Spawn ruby process, capture output
    const startTime = Date.now();
    // ... execution logic ...
    return {
      success: true,
      stdout: output,
      stderr: '',
      executionTime: Date.now() - startTime
    };
  },

  async isAvailable() {
    // Check if ruby is installed
    return true;
  }
};

// Register returns a Disposable for cleanup
const disposable = registerBabelExecutor(rubyExecutor);
context.subscriptions.push(disposable);

import { createSimpleExecutor, registerBabelExecutor } from './adapters/babelExecutorAdapter';

// Create an executor that writes code to a temp file and runs a command
const rubyExecutor = createSimpleExecutor({
  languages: ['ruby', 'rb'],
  command: 'ruby',
  extension: '.rb',
  args: [],  // Optional: arguments before the file
  timeout: 30000,  // Optional: default timeout
  transformCode: (code, ctx) => code,  // Optional: transform code
});

context.subscriptions.push(registerBabelExecutor(rubyExecutor));

interface BlockExportHandler {
  /** Block type name (case-insensitive, e.g., 'sidebar') */
  blockType: string;

  /** Optional description for documentation */
  description?: string;

  /**
   * Export the block content for a specific backend
   * @param content The processed content inside the block
   * @param backend The export backend ('html', 'latex', 'text')
   * @param context Additional context about the block
   * @returns The exported string, or undefined to use default handling
   */
  export(
    content: string,
    backend: 'html' | 'latex' | 'text',
    context: BlockExportContext
  ): string | undefined;
}

interface BlockExportContext {
  blockType: string;
  parameters?: string;  // From #+BEGIN_foo :param value
  filePath?: string;
  affiliated?: {
    name?: string;
    caption?: string;
    [key: string]: string | undefined;
  };
}

import { registerBlockExport, BlockExportHandler } from './adapters/blockExportAdapter';

const calloutHandler: BlockExportHandler = {
  blockType: 'callout',
  description: 'Custom callout blocks',

  export(content, backend, context) {
    const title = context.parameters?.trim() || 'Note';

    switch (backend) {
      case 'html':
        return `<div class="callout">\n<strong>${title}</strong>\n${content}</div>`;
      case 'latex':
        return `\\begin{tcolorbox}[title=${title}]\n${content}\\end{tcolorbox}`;
      default:
        return undefined;  // Use default handling for 'text' backend
    }
  }
};

const disposable = registerBlockExport(calloutHandler);
context.subscriptions.push(disposable);

interface BlockHighlightConfig {
  /** Block type to highlight (case-insensitive) */
  blockType: string;

  /** Background color for the block (CSS color or theme variable) */
  backgroundColor?: string;

  /** Color for the #+BEGIN/#+END lines */
  headerColor?: string;

  /** Border color (left border is common) */
  borderColor?: string;

  /** Whether content should be italic */
  italic?: boolean;
}

import { registerBlockHighlight } from './adapters/blockHighlightAdapter';

const disposable = registerBlockHighlight({
  blockType: 'callout',
  backgroundColor: 'rgba(100, 149, 237, 0.1)',
  borderColor: 'rgba(100, 149, 237, 0.5)',
  headerColor: 'cornflowerblue',
});

context.subscriptions.push(disposable);

interface ExportHook {
  /** Unique identifier for this hook */
  id: string;

  /** Optional description */
  description?: string;

  /** Priority for ordering (higher runs first, default 0) */
  priority?: number;

  /**
   * Pre-export hook - runs before export starts
   * Can modify export options
   */
  preExport?: (context: PreExportContext) => ExportOptions | undefined;

  /**
   * Post-export hook - runs after export completes
   * Can transform the final output
   */
  postExport?: (output: string, context: PostExportContext) => string | undefined;

  /**
   * Element filter - runs for each element during export
   * Can override the rendered output for specific elements
   */
  elementFilter?: (rendered: string, context: ElementFilterContext) => string | undefined;
}

interface PreExportContext {
  document: OrgDocumentNode;
  options: ExportOptions;
  backend: string;  // 'html', 'latex', etc.
  filePath?: string;
}

interface PostExportContext {
  backend: string;
  options: ExportOptions;
  filePath?: string;
}

interface ElementFilterContext {
  element: OrgElement;
  backend: string;
  options: ExportOptions;
  parent?: OrgElement;
}

import { registerExportHook } from './adapters/exportHooksAdapter';

// Add a company header/footer to HTML exports
const disposable = registerExportHook({
  id: 'company-branding',
  description: 'Add company header and footer',

  postExport: (output, context) => {
    if (context.backend === 'html') {
      return `<!-- Company Header -->\n${output}\n<!-- Company Footer -->`;
    }
    return undefined; // Don't modify other backends
  }
});

context.subscriptions.push(disposable);

interface SpeedCommand {
  key: string;
  description: string;
  execute(editor: TextEditor, heading: HeadingNode): Promise<void>;
}

interface CaptureTemplate {
  key: string;
  description: string;
  template: string;
  target: CaptureTarget;
}

interface OrgEntity {
  name: string;
  latex: string;
  html: string;
  unicode: string;
}

interface LintRule {
  id: string;
  severity: 'error' | 'warning' | 'info';
  check(document: OrgDocument): Diagnostic[];
}

const disposable = scimaxApi.registerBabelExecutor({
  languages: ['ruby', 'rb'],
  async execute(code, context) {
    return { success: true, stdout: 'result', stderr: '', executionTime: 100 };
  },
  async isAvailable() {
    return true;
  }
});

context.subscriptions.push(disposable);

const rubyExec = scimaxApi.createSimpleExecutor({
  languages: ['ruby'],
  command: 'ruby',
  extension: '.rb',
});

context.subscriptions.push(scimaxApi.registerBabelExecutor(rubyExec));

const disposable = scimaxApi.registerLinkType({
  type: 'jira',
  description: 'Jira issue links',
  resolve: (path) => ({
    displayText: path,
    url: `https://jira.example.com/browse/${path}`,
    tooltip: `Open Jira issue ${path}`
  }),
  export: (path, desc, backend) => {
    const url = `https://jira.example.com/browse/${path}`;
    const text = desc || path;
    if (backend === 'html') return `<a href="${url}">${text}</a>`;
    if (backend === 'latex') return `\\href{${url}}{${text}}`;
    return text;
  }
});

context.subscriptions.push(disposable);

const disposable = scimaxApi.registerLinkFollowHandler({
  type: 'jira',
  async follow(path, context) {
    await vscode.env.openExternal(
      vscode.Uri.parse(`https://jira.example.com/browse/${path}`)
    );
  }
});

context.subscriptions.push(disposable);

const disposable = scimaxApi.registerBlockExport({
  blockType: 'callout',
  export: (content, backend, ctx) => {
    if (backend === 'html') return `<div class="callout">${content}</div>`;
    if (backend === 'latex') return `\\begin{tcolorbox}${content}\\end{tcolorbox}`;
    return content;
  },
});

context.subscriptions.push(disposable);

const disposable = scimaxApi.registerBlockHighlight({
  blockType: 'callout',
  backgroundColor: 'rgba(100, 149, 237, 0.1)',
  borderColor: 'rgba(100, 149, 237, 0.5)',
  headerColor: 'cornflowerblue',
});

context.subscriptions.push(disposable);

const disposable = scimaxApi.registerExportHook({
  id: 'my-custom-hook',
  // Modify options before export
  preExport: (ctx) => ({ ...ctx.options, toc: true }),
  // Transform output after export
  postExport: (output, ctx) => {
    if (ctx.backend === 'html') {
      return `<!-- Custom Header -->\n${output}`;
    }
    return undefined;
  },
  // Filter specific elements
  elementFilter: (rendered, ctx) => {
    if (ctx.element.type === 'paragraph') {
      return `<div class="para">${rendered}</div>`;
    }
    return undefined;
  },
});

context.subscriptions.push(disposable);

const hook = scimaxApi.createWrapperHook('my-wrapper', {
  backend: 'html',           // Optional: filter by backend
  before: '<!-- Start -->',
  after: '<!-- End -->',
  priority: 10,              // Optional: higher runs first
});

context.subscriptions.push(scimaxApi.registerExportHook(hook));

const hook = scimaxApi.createElementReplacerHook('para-wrapper', {
  elementType: ['paragraph', 'headline'],  // Can be string or array
  backend: 'html',                         // Optional: filter by backend
  replace: (rendered, element) => {
    return `<div class="custom">${rendered}</div>`;
  },
});

context.subscriptions.push(scimaxApi.registerExportHook(hook));

// Access all registries
const { registries } = scimaxApi;

// Check registered block types
registries.blockExport.getBlockTypes();  // ['warning', 'note', ...]

// Check if a block has a custom handler
registries.blockExport.hasHandler('callout');  // true/false

// Get highlight config for a block type
registries.blockHighlight.getConfig('warning');

// Get all export hooks
registries.exportHook.getHooks();  // Sorted by priority

// Check if a hook is registered
registries.exportHook.hasHook('my-hook');  // true/false

// Check if a language is supported
scimaxApi.isLanguageSupported('python');  // true

// Get all registered languages
scimaxApi.getRegisteredLanguages();  // ['python', 'py', 'bash', ...]