/*
 * @Author: ZhaoYing 
 * @Date: 2025-12-23 16:22:51 
 * @Last Modified by: ZhaoYing
 * @Last Modified time: 2026-03-03 10:11:48
 */
import { type FC, useState, useEffect, useMemo } from 'react';
import { LexicalComposer } from '@lexical/react/LexicalComposer';
import { RichTextPlugin } from '@lexical/react/LexicalRichTextPlugin';
import { ContentEditable } from '@lexical/react/LexicalContentEditable';
import { HistoryPlugin } from '@lexical/react/LexicalHistoryPlugin';
// import { AutoFocusPlugin } from '@lexical/react/LexicalAutoFocusPlugin';
import { LexicalErrorBoundary } from '@lexical/react/LexicalErrorBoundary';
// import { HeadingNode, QuoteNode } from '@lexical/rich-text';
// import { ListItemNode, ListNode } from '@lexical/list';
// import { LinkNode } from '@lexical/link';
// import { CodeNode } from '@lexical/code';

import AutocompletePlugin, { type Suggestion } from './plugin/AutocompletePlugin'
import CharacterCountPlugin from './plugin/CharacterCountPlugin'
import InitialValuePlugin from './plugin/InitialValuePlugin';
import CommandPlugin from './plugin/CommandPlugin';
import Jinja2HighlightPlugin from './plugin/Jinja2HighlightPlugin';
import LineNumberPlugin from './plugin/LineNumberPlugin';
import BlurPlugin from './plugin/BlurPlugin';
import { VariableNode } from './nodes/VariableNode'

// Props interface for Lexical Editor component
export interface LexicalEditorProps {
  placeholder?: string;
  value?: string;
  onChange?: (value: string) => void;
  options?: Suggestion[];
  variant?: 'outlined' | 'borderless';
  height?: number;
  fontSize?: number;
  lineHeight?: number;
  size?: 'default' | 'small';
  type?: 'input' | 'textarea',
  language?: 'string' | 'jinja2';
  className?: string;
}

// Default theme for editor
const theme = {
  paragraph: 'editor-paragraph',
  text: {
    bold: 'editor-text-bold',
    italic: 'editor-text-italic',
  },
};

// Theme with Jinja2 syntax highlighting
const jinja2Theme = {
  ...theme,
  code: 'jinja2-expression',
  text: {
    ...theme.text,
    code: 'jinja2-inline',
  },
};

// Main Lexical Editor component
const Editor: FC<LexicalEditorProps> =(({
  placeholder = "请输入内容...",
  value = "",
  onChange,
  options = [],
  variant = 'borderless',
  size = 'default',
  type = 'textarea',
  language = 'string',
  height,
  className
}) => {
  const [_count, setCount] = useState(0);
  const [enableJinja2, setEnableJinja2] = useState(false)
  const [enableLineNumbers, setEnableLineNumbers] = useState(false)

  // Setup Jinja2 mode and inject styles when language changes
  useEffect(() => {
    const needsLineNumbers = language === 'jinja2';
    setEnableJinja2(language === 'jinja2');
    setEnableLineNumbers(needsLineNumbers);

    if (needsLineNumbers) {
      const styleId = 'code-editor-styles';
      let existingStyle = document.getElementById(styleId);

      if (!existingStyle) {
        const style = document.createElement('style');
        style.id = styleId;
        style.textContent = `
          .jinja2-expression {
            background-color: #f6f8fa !important;
            border: 1px solid #d1d9e0 !important;
            border-radius: 3px !important;
            padding: 2px 4px !important;
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace !important;
            font-size: 13px !important;
            color: #0969da !important;
          }
          .jinja2-inline {
            background-color: #f6f8fa !important;
            padding: 1px 3px !important;
            border-radius: 2px !important;
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace !important;
            font-size: 13px !important;
            color: #0969da !important;
          }
          .editor-paragraph {
            margin: 0;
          }
          .editor-paragraph:has-text('{') .editor-text,
          .editor-paragraph:has-text('[') .editor-text {
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace !important;
          }
          .editor-with-line-numbers {
            display: flex;
          }
          .line-numbers {
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
            font-size: 12px;
            line-height: 16px;
            padding: 4px 8px;
            text-align: right;
            user-select: none;
            display: flex;
            flex-direction: column;
          }
          .line-numbers > div {
            min-height: 20px;
            display: flex;
            align-items: flex-start;
          }
          .editor-content-wrapper {
            flex: 1;
          }
          .editor-content-with-numbers {
            white-space: pre-wrap;
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
          }
          .editor-content-with-numbers p {
            margin: 0;
            min-height: 20px;
          }
        `;
        document.head.appendChild(style);
      }
    }
  }, [language])

  // Lexical editor configuration
  const initialConfig = {
    namespace: 'AutocompleteEditor',
    theme: enableJinja2 ? jinja2Theme : theme,
    nodes: enableJinja2 ? [
      // When Jinja2 is enabled, use plain text instead of VariableNode
    ] : [
      // HeadingNode,
      // QuoteNode,
      // ListItemNode,
      // ListNode,
      // LinkNode,
      // CodeNode,
      VariableNode,
    ],
    onError: (error: Error) => {
      console.error(error);
    },
  };

  // Calculate minimum height based on type and size
  const minheight = useMemo(() => {
    if (type === 'input') {
      return `${height ? height : size === 'small' ? 28 : 30}px`
    }
    return `${height ? height : size === 'small' ? 60 : 120}px`
  }, [type, size, height])

  // Calculate font size based on size prop
  const fontSize = useMemo(() => {
    return `${size === 'small' ? 12 : 14}px`
  }, [size])

  // Calculate line height based on size prop
  const lineHeight = useMemo(() => {
    return `${height ? height : size === 'small' ? 16 : 20}px`
  }, [size])

  // Calculate placeholder minimum height
  const placeHolderMinheight = useMemo(() => {
    return `${height ? height : size === 'small' ? 16 : 30}px`
  }, [type, size, height])

  return (
    <LexicalComposer initialConfig={initialConfig}>
      <div style={{ position: 'relative' }} className={className}>
        <RichTextPlugin
          contentEditable={
            enableLineNumbers ? (
              // Editor with line numbers for Jinja2 mode
              <div className="editor-with-line-numbers" style={{
                border: variant === 'borderless' ? 'none' : '1px solid #DFE4ED',
                borderRadius: '6px',
                minHeight: minheight,
              }}>
                <div className="line-numbers">
                  <div>1</div>
                </div>
                <div className="editor-content-wrapper">
                  <ContentEditable
                    className="editor-content-with-numbers"
                    style={{
                      minHeight: minheight,
                      padding: '4px 0',
                      outline: 'none',
                      resize: 'none',
                      fontSize: fontSize,
                      lineHeight: lineHeight,
                      border: 'none',
                    }}
                  />
                </div>
              </div>
            ) : (
              // Standard editor without line numbers
              <ContentEditable
                style={{
                  minHeight: minheight,
                  padding: variant === 'borderless' ? '0' : '4px 11px',
                  border: variant === 'borderless' ? 'none' : '1px solid #DFE4ED',
                  borderRadius: '6px',
                  outline: 'none',
                  resize: 'none',
                  fontSize: fontSize,
                  lineHeight: lineHeight,
                }}
              />
            )
          }
          placeholder={
            <div
              style={{
                minHeight: placeHolderMinheight,
                position: 'absolute',
                top: enableLineNumbers ? '4px' : variant === 'borderless' ? '0' : '6px',
                left: enableLineNumbers ? '16px' : (variant === 'borderless' ? '0' : '11px'),
                color: '#A8A9AA',
                fontSize: fontSize,
                lineHeight: placeHolderMinheight,
                pointerEvents: 'none',
              }}
            >
              {placeholder}
            </div>
          }
          ErrorBoundary={LexicalErrorBoundary}
        />
        {/* Editor plugins */}
        <HistoryPlugin />
        <CommandPlugin />
        {language === 'jinja2' && <Jinja2HighlightPlugin />}
        {enableLineNumbers && <LineNumberPlugin />}
        <AutocompletePlugin options={options} enableJinja2={enableJinja2} />
        <CharacterCountPlugin setCount={(count) => { setCount(count) }} onChange={onChange} />
        <InitialValuePlugin value={value} options={options} enableLineNumbers={enableLineNumbers} />
        <BlurPlugin enableJinja2={enableJinja2} />
      </div>
    </LexicalComposer>
  );
});

export default Editor;
