import React from "react";
import { Editor } from "slate";
import { ReactEditor } from "slate-react";
import { getFullEditorTextWithNewlines } from "../../lib/get-text-around-cursor";
import { replaceEditorText } from "../../lib/slatejs-edits/replace-text";
import { HTMLCopilotTextAreaElement } from "../../types";
import { CustomEditor } from "../../types/base/custom-editor";

export function usePopulateCopilotTextareaRef(
  editor: Editor,
  ref: React.Ref<HTMLCopilotTextAreaElement>,
) {
  React.useImperativeHandle(ref, () => {
    class Combined {
      constructor(
        private customMethods: CustomMethods,
        private editorHtmlElement: HTMLElement,
      ) {}

      [key: string]: any;

      get(target: any, propKey: string): any {
        if (this.isKeyOfCustomMethods(propKey)) {
          const value = this.customMethods[propKey];
          if (typeof value === "function") {
            return value.bind(this.customMethods);
          }
          return value;
        } else if (this.isKeyOfHTMLElement(propKey)) {
          const value = this.editorHtmlElement[propKey];
          if (typeof value === "function") {
            return value.bind(this.editorHtmlElement);
          }
          return value;
        }
      }

      set(target: any, propKey: string, value: any): boolean {
        if (this.isKeyOfCustomMethods(propKey)) {
          (this.customMethods as any)[propKey] = value;
        } else if (this.isKeyOfHTMLElement(propKey)) {
          (this.editorHtmlElement as any)[propKey] = value;
        } else {
          // Default behavior (optional)
          target[propKey] = value;
        }
        return true;
      }

      private isKeyOfCustomMethods(key: string): key is keyof CustomMethods {
        return key in this.customMethods;
      }

      private isKeyOfHTMLElement(key: string): key is keyof HTMLElement {
        return key in this.editorHtmlElement;
      }
    }

    const handler = {
      get(target: any, propKey: keyof CustomMethods | keyof HTMLElement) {
        return target.get(target, propKey);
      },
      set(
        target: any,
        propKey: keyof CustomMethods | keyof HTMLElement,
        value: any,
      ) {
        return target.set(target, propKey, value);
      },
    };

    class CustomMethods {
      constructor(private editor: CustomEditor) {}

      focus() {
        ReactEditor.focus(this.editor);
      }

      blur() {
        ReactEditor.blur(this.editor);
      }

      get value() {
        return getFullEditorTextWithNewlines(this.editor);
      }
      set value(value: string) {
        replaceEditorText(this.editor, value);
      }
    }

    const editorHtmlElement = ReactEditor.toDOMNode(editor, editor);
    const customMethods = new CustomMethods(editor);

    const combined = new Combined(customMethods, editorHtmlElement);
    return new Proxy(combined, handler);
  }, [editor]);
}