'use client'

import { memo, useMemo } from 'react'
import ReactMarkdown from 'react-markdown'
import remarkGfm from 'remark-gfm'
import remarkMath from 'remark-math'
import rehypeKatex from 'rehype-katex'
import rehypeRaw from 'rehype-raw'
import 'katex/dist/katex.min.css'
import { NoteChartFromCode } from './note-chart'

// Memoized wrapper to prevent infinite re-renders
const ChartWrapper = memo(function ChartWrapper({ code }: { code: string }) {
  return <NoteChartFromCode code={code} />
})

interface MarkdownContentProps {
  content: string
  className?: string
}

export const MarkdownContent = memo(function MarkdownContent({ content, className }: MarkdownContentProps) {
  // Strip <think>...</think> and <thinking>...</thinking> blocks produced by reasoning models
  // (MiniMax, DeepSeek R1, etc.) before passing to ReactMarkdown — rehypeRaw would otherwise
  // try to render them as HTML elements causing React warnings.
  // Also handles partial/unclosed blocks during streaming (e.g. <think> without </think> yet).
  const safeContent = useMemo(
    () => content
      .replace(/<think>[\s\S]*?<\/think>/gi, '')    // complete think blocks
      .replace(/<think>[\s\S]*/i, '')               // unclosed think block (still streaming)
      .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '') // complete thinking blocks
      .replace(/<thinking>[\s\S]*/i, '')            // unclosed thinking block
      .trim(),
    [content]
  )


  return (
    <div dir="auto" className={`prose prose-sm prose-compact dark:prose-invert max-w-none break-words ${className}`}>
      <ReactMarkdown
        remarkPlugins={[remarkGfm, remarkMath]}
        rehypePlugins={[rehypeKatex, rehypeRaw]}
        components={{
          a: ({ node, ...props }) => (
            <a {...props} className="text-primary hover:underline" target="_blank" rel="noopener noreferrer" />
          ),
          code({ node, inline, className, children, ...props }: any) {
            const match = /language-(\w+)/.exec(className || '')
            const language = match ? match[1] : ''

            // Chart code blocks - memoized to prevent infinite loops
            if (language === 'chart') {
              const chartCode = String(children).replace(/\n$/, '')
              return <ChartWrapper key={chartCode.slice(0, 50)} code={chartCode} />
            }

            // Other code blocks
            if (!inline && match) {
              return (
                <code className={className} {...props}>
                  {children}
                </code>
              )
            }

            return (
              <code className="bg-muted px-1.5 py-0.5 rounded text-sm" {...props}>
                {children}
              </code>
            )
          },
        }}
      >
        {safeContent}
      </ReactMarkdown>
    </div>
  )
})