export interface BlockWriteAIBlock<TData = Record<string, unknown>> {
  id?: string;
  type: string;
  data: TData;
}

export interface BlockWriteAIDocument {
  time?: number;
  version?: string;
  blocks: BlockWriteAIBlock[];
  signatures?: Record<string, unknown>;
  [key: string]: unknown;
}

export interface BlockWriteAIUploadResult {
  url: string;
  name?: string;
  size?: number;
  type?: string;
  alt?: string;
  caption?: string;
  base64?: string;
  upload?: Record<string, unknown>;
  [key: string]: unknown;
}

export interface BlockWriteAIUploadHandlers {
  image?: (file: File) => Promise<BlockWriteAIUploadResult> | BlockWriteAIUploadResult;
  file?: (file: File) => Promise<BlockWriteAIUploadResult> | BlockWriteAIUploadResult;
}

export interface BlockWriteAIAutosaveOptions {
  key: string;
  load?: boolean;
}

export interface BlockWriteAIAIOptions {
  endpoint?: string;
}

export interface BlockWriteAIPremiumState {
  status: "missing" | "pending" | "valid" | "invalid" | "disabled" | string;
  valid: boolean;
  message?: string;
  features: Record<"drawing" | "mermaid" | "signature" | "signature_flow" | "ai", boolean> & Record<string, boolean>;
  limits?: Record<string, unknown>;
  usage?: Record<string, unknown>;
  organization?: Record<string, unknown> | null;
  subscription?: Record<string, unknown> | null;
  license?: Record<string, unknown> | null;
}

export interface BlockWriteAIPremiumOptions {
  disabled?: boolean;
  licenseKey?: string;
  license_key?: string;
  key?: string;
  verifyEndpoint?: string;
  verify?: string;
  endpoint?: string;
  usageEndpoint?: string;
  usage?: string;
  featureUsageEndpoint?: string;
  premiumUsageEndpoint?: string;
  eventEndpoint?: string;
  premiumEventEndpoint?: string;
  signatureEventEndpoint?: string;
  signatureEvent?: string;
  pluginEndpoint?: string;
  pluginsEndpoint?: string;
  bundleEndpoint?: string;
  features?: string[];
  pluginFeatures?: string[];
  autoLoadPlugins?: boolean;
  loadPlugins?: boolean;
}

export interface BlockWriteAIPremiumPluginLoadOptions {
  licenseKey?: string;
  license_key?: string;
  license?: string;
  sessionToken?: string;
  session_token?: string;
  endpoint?: string;
  pluginEndpoint?: string;
  pluginsEndpoint?: string;
  bundleEndpoint?: string;
  signatureEventEndpoint?: string;
  signatureEvent?: string;
  features?: string[];
}

export type BlockWriteAIToolConfig = string[] | Record<string, boolean>;
export type BlockWriteAIUploadOutput = "base64" | "upload";

export interface BlockWriteAIExportOptions {
  html?: boolean;
  buttons?: boolean;
  exportToHTML?: boolean;
  exportButtons?: boolean;
  "Export To HTML"?: boolean;
  "Export Buttons"?: boolean;
}

export interface BlockWriteAIShellOptions {
  showHeader?: boolean;
  title?: string;
  subtitle?: string | false;
  heading?: string;
  status?: string;
  logo?: string | false;
  logoUrl?: string | false;
  branding?: {
    logo?: string | false;
    [key: string]: unknown;
  };
  maxWidth?: string | number;
  className?: string;
}

export interface BlockWriteAIOptions {
  holder: string | HTMLElement;
  data?: BlockWriteAIDocument;
  placeholder?: string;
  minHeight?: string;
  maxWidth?: string | number;
  editorMaxWidth?: string | number;
  shell?: boolean | BlockWriteAIShellOptions;
  showHeader?: boolean;
  shellTitle?: string;
  shellSubtitle?: string | false;
  shellHeading?: string;
  shellStatus?: string;
  shellLogo?: string | false;
  logoUrl?: string | false;
  branding?: {
    logo?: string | false;
    [key: string]: unknown;
  };
  shellClassName?: string;
  autofocus?: boolean;
  readOnly?: boolean;
  tools?: BlockWriteAIToolConfig;
  autosave?: BlockWriteAIAutosaveOptions;
  upload?: BlockWriteAIUploadHandlers;
  uploadOutput?: BlockWriteAIUploadOutput | BlockWriteAIUploadOutput[];
  "upload output"?: BlockWriteAIUploadOutput | BlockWriteAIUploadOutput[];
  export?: BlockWriteAIExportOptions;
  Export?: BlockWriteAIExportOptions;
  exportButton?: boolean;
  exportHtmlButton?: boolean;
  saveButton?: boolean;
  licenseKey?: string;
  license_key?: string;
  license?: string;
  licenseVerifyEndpoint?: string;
  aiUsageEndpoint?: string;
  premiumPluginEndpoint?: string;
  premiumPluginFeatures?: string[];
  autoLoadPremiumPlugins?: boolean;
  premium?: false | BlockWriteAIPremiumOptions;
  Premium?: false | BlockWriteAIPremiumOptions;
  ai?: false | BlockWriteAIAIOptions;
  onChange?: (data: BlockWriteAIDocument, editor: BlockWriteAI) => void;
  onSave?: (data: BlockWriteAIDocument, editor: BlockWriteAI) => void | Promise<void>;
}

export default class BlockWriteAI {
  constructor(options: BlockWriteAIOptions);

  readonly readOnly: boolean;

  save(): Promise<BlockWriteAIDocument>;
  getData(): BlockWriteAIDocument;
  render(data: BlockWriteAIDocument): void;
  clear(): void;
  exportHTML(): string;
  exportMarkdown(): string;
  importHTML(html: string): void;
  setReadOnly(readOnly: boolean): void;
  setShellStatus(status: string): void;
  verifyPremiumLicense(): Promise<BlockWriteAIPremiumState>;
  loadPremiumPlugins(features?: string[]): Promise<{ ok: boolean; features: string[] }>;
  getPremiumState(): BlockWriteAIPremiumState;
  isPremiumFeatureEnabled(feature: "drawing" | "mermaid" | "signature" | "signature_flow" | "ai" | string): boolean;
  consumePremiumUsage(feature: "ai" | string, metadata?: Record<string, unknown>): Promise<BlockWriteAIPremiumState>;
  openAI(): this | null;
  destroy(): void;

  static version: string;
  static platformEndpoints: {
    premiumPlugins: string;
    licenseVerify: string;
    aiUsage: string;
    aiGenerate: string;
    premiumUsage: string;
    premiumEvent: string;
    signatureEvent: string;
  };
  static configure(options: Partial<BlockWriteAIOptions>): typeof BlockWriteAI;
  static loadPremiumPlugins(options: BlockWriteAIPremiumPluginLoadOptions): Promise<{ ok: boolean; features: string[] }>;
  static enableAI(options?: BlockWriteAIAIOptions): typeof BlockWriteAI;
  static registerTool(name: string, tool: unknown): void;
  static getTool(name: string): unknown;
  static normalizePreviewData(payload: unknown): BlockWriteAIDocument;
  static toHTML(data: BlockWriteAIDocument | { data?: BlockWriteAIDocument }, options?: Partial<BlockWriteAIOptions>): string;
  static initPreviewPlugins(root?: HTMLElement | Document): HTMLElement | Document | undefined;
  static primeSignatureData(signatures?: Record<string, unknown>): Record<string, unknown> | undefined;
  static renderPreview(holder: string | HTMLElement, data: BlockWriteAIDocument | { data?: BlockWriteAIDocument }, options?: Partial<BlockWriteAIOptions>): HTMLElement | null;
  static mountPreviews(options?: {
    selector?: string;
    source?: string;
    data?: BlockWriteAIDocument | { data?: BlockWriteAIDocument };
    force?: boolean;
    editor?: Partial<BlockWriteAIOptions>;
  }): Promise<HTMLElement[]>;
  static helpers: Record<string, unknown>;
}

declare global {
  interface Window {
    BlockWriteAI: typeof BlockWriteAI;
    RichBlockEditor: typeof BlockWriteAI;
  }
}