/// Utility class for parsing and extracting reasoning/thinking content from messages.
///
/// This parser handles:
/// - `<details type="reasoning">` blocks (server-emitted, preferred)
/// - Raw tag pairs like `<think>`, `<thinking>`, `<reasoning>`, etc.
///
/// Reference: openwebui-src/backend/open_webui/utils/middleware.py DEFAULT_REASONING_TAGS
library;

import 'html_utils.dart';

/// All reasoning tag pairs supported by Open WebUI.
/// Reference: DEFAULT_REASONING_TAGS in middleware.py
const List<(String, String)> defaultReasoningTagPairs = [
  ('<think>', '</think>'),
  ('<thinking>', '</thinking>'),
  ('<reason>', '</reason>'),
  ('<reasoning>', '</reasoning>'),
  ('<thought>', '</thought>'),
  ('<Thought>', '</Thought>'),
  ('<|begin_of_thought|>', '<|end_of_thought|>'),
  ('◁think▷', '◁/think▷'),
];

/// Lightweight reasoning block for segmented rendering.
class ReasoningEntry {
  final String reasoning;
  final String summary;
  final int duration;
  final bool isDone;

  const ReasoningEntry({
    required this.reasoning,
    required this.summary,
    required this.duration,
    required this.isDone,
  });

  String get formattedDuration => ReasoningParser.formatDuration(duration);

  /// Gets the cleaned reasoning text (removes leading '>' from blockquote format).
  String get cleanedReasoning {
    return reasoning
        .split('\n')
        .map((line) {
          // Remove leading '>' and optional space (blockquote format from server)
          if (line.startsWith('> ')) return line.substring(2);
          if (line.startsWith('>')) return line.substring(1);
          return line;
        })
        .join('\n')
        .trim();
  }
}

/// Ordered segment that is either plain text or a reasoning entry.
class ReasoningSegment {
  final String? text;
  final ReasoningEntry? entry;

  const ReasoningSegment._({this.text, this.entry});

  factory ReasoningSegment.text(String text) => ReasoningSegment._(text: text);
  factory ReasoningSegment.entry(ReasoningEntry entry) =>
      ReasoningSegment._(entry: entry);

  bool get isReasoning => entry != null;
}

/// Model class for reasoning content (legacy, kept for compatibility).
class ReasoningContent {
  final String reasoning;
  final String summary;
  final int duration;
  final bool isDone;
  final String mainContent;
  final String originalContent;

  const ReasoningContent({
    required this.reasoning,
    required this.summary,
    required this.duration,
    required this.isDone,
    required this.mainContent,
    required this.originalContent,
  });

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is ReasoningContent &&
          runtimeType == other.runtimeType &&
          reasoning == other.reasoning &&
          summary == other.summary &&
          duration == other.duration &&
          isDone == other.isDone &&
          mainContent == other.mainContent &&
          originalContent == other.originalContent;

  @override
  int get hashCode =>
      reasoning.hashCode ^
      summary.hashCode ^
      duration.hashCode ^
      isDone.hashCode ^
      mainContent.hashCode ^
      originalContent.hashCode;

  String get formattedDuration => ReasoningParser.formatDuration(duration);

  /// Gets the cleaned reasoning text (removes leading '>').
  String get cleanedReasoning {
    return reasoning
        .split('\n')
        .map((line) {
          if (line.startsWith('> ')) return line.substring(2);
          if (line.startsWith('>')) return line.substring(1);
          return line;
        })
        .join('\n')
        .trim();
  }
}

/// Utility class for parsing and extracting reasoning/thinking content.
class ReasoningParser {
  /// Patterns that indicate a details block is reasoning content.
  /// Used when the `type` attribute is missing.
  static final _reasoningSummaryPattern = RegExp(
    r'Thought|Thinking|Reasoning',
    caseSensitive: false,
  );

  /// Splits content into ordered segments of plain text and reasoning entries.
  ///
  /// Handles:
  /// - `<details type="reasoning">` blocks with optional summary/duration/done
  /// - `<details>` blocks without type but with reasoning-like summary
  /// - Raw tag pairs like `<think>`, `<thinking>`, `<reasoning>`, etc.
  /// - Incomplete/streaming cases by emitting a partial reasoning entry
  static List<ReasoningSegment>? segments(
    String content, {
    List<(String, String)>? customTagPairs,
    bool detectDefaultTags = true,
  }) {
    if (content.isEmpty) return null;

    // Build the list of raw tag pairs to detect
    final tagPairs = <(String, String)>[];
    if (customTagPairs != null) {
      tagPairs.addAll(customTagPairs);
    }
    if (detectDefaultTags) {
      tagPairs.addAll(defaultReasoningTagPairs);
    }

    final segments = <ReasoningSegment>[];
    int index = 0;

    while (index < content.length) {
      // Find the earliest match: either <details (any type) or a raw tag
      int nextDetailsIdx = -1;
      int nextRawIdx = -1;
      (String, String)? matchedRawPair;

      // Check for any <details tag (we'll determine if it's reasoning later)
      final detailsMatch = RegExp(
        r'<details(?:\s|>)',
      ).firstMatch(content.substring(index));
      if (detailsMatch != null) {
        nextDetailsIdx = index + detailsMatch.start;
      }

      // Check for raw tag pairs
      for (final pair in tagPairs) {
        final startTag = pair.$1;
        final idx = content.indexOf(startTag, index);
        if (idx != -1 && (nextRawIdx == -1 || idx < nextRawIdx)) {
          nextRawIdx = idx;
          matchedRawPair = pair;
        }
      }

      // Determine which comes first
      final int nextIdx;
      final String kind;
      if (nextDetailsIdx == -1 && nextRawIdx == -1) {
        // No more reasoning blocks
        if (index < content.length) {
          final remaining = content.substring(index);
          if (remaining.trim().isNotEmpty) {
            segments.add(ReasoningSegment.text(remaining));
          }
        }
        break;
      } else if (nextDetailsIdx != -1 &&
          (nextRawIdx == -1 || nextDetailsIdx <= nextRawIdx)) {
        nextIdx = nextDetailsIdx;
        kind = 'details';
      } else {
        nextIdx = nextRawIdx;
        kind = 'raw';
      }

      // Add text before this block
      if (nextIdx > index) {
        final textBefore = content.substring(index, nextIdx);
        if (textBefore.trim().isNotEmpty) {
          segments.add(ReasoningSegment.text(textBefore));
        }
      }

      if (kind == 'details') {
        // Parse <details> block and check if it's reasoning content
        final result = _parseDetailsBlock(content, nextIdx);

        // Only add as reasoning if it's a reasoning type or looks like reasoning
        if (result.isReasoning) {
          segments.add(ReasoningSegment.entry(result.entry));
        } else {
          // Not a reasoning block, treat as text
          final detailsText = content.substring(nextIdx, result.endIndex);
          if (detailsText.trim().isNotEmpty) {
            segments.add(ReasoningSegment.text(detailsText));
          }
        }

        if (!result.isComplete) {
          // Incomplete block, stop here
          break;
        }
        index = result.endIndex;
      } else if (kind == 'raw' && matchedRawPair != null) {
        // Parse raw tag pair
        final result = _parseRawReasoning(
          content,
          nextIdx,
          matchedRawPair.$1,
          matchedRawPair.$2,
        );
        segments.add(ReasoningSegment.entry(result.entry));

        if (!result.isComplete) {
          // Incomplete block, stop here
          break;
        }
        index = result.endIndex;
      }
    }

    return segments.isEmpty ? null : segments;
  }

  /// Parse a `<details>` block starting at the given index.
  /// Returns whether the block is reasoning content based on type or summary.
  static _DetailsResult _parseDetailsBlock(String content, int startIdx) {
    // Find the opening tag end
    final openTagEnd = content.indexOf('>', startIdx);
    if (openTagEnd == -1) {
      // Incomplete opening tag - assume reasoning for streaming
      return _DetailsResult(
        entry: ReasoningEntry(
          reasoning: '',
          summary: '',
          duration: 0,
          isDone: false,
        ),
        endIndex: content.length,
        isComplete: false,
        isReasoning: true,
      );
    }

    final openTag = content.substring(startIdx, openTagEnd + 1);

    // Parse attributes
    final attrs = <String, String>{};
    final attrRegex = RegExp(r'(\w+)="([^"]*)"');
    for (final m in attrRegex.allMatches(openTag)) {
      attrs[m.group(1)!] = m.group(2) ?? '';
    }

    final type = attrs['type'] ?? '';
    final isDone = (attrs['done'] ?? 'true') == 'true';
    final duration = int.tryParse(attrs['duration'] ?? '0') ?? 0;

    // Find matching closing tag with nesting support
    int depth = 1;
    int i = openTagEnd + 1;
    while (i < content.length && depth > 0) {
      final nextOpen = content.indexOf('<details', i);
      final nextClose = content.indexOf('</details>', i);
      if (nextClose == -1) break;
      if (nextOpen != -1 && nextOpen < nextClose) {
        depth++;
        i = nextOpen + '<details'.length;
      } else {
        depth--;
        i = nextClose + '</details>'.length;
      }
    }

    if (depth != 0) {
      // Incomplete block (streaming)
      final innerContent = content.substring(openTagEnd + 1);
      final summaryResult = _extractSummary(innerContent);

      // Determine if this is reasoning based on type or summary
      final isReasoning =
          type == 'reasoning' ||
          (type.isEmpty &&
              _reasoningSummaryPattern.hasMatch(summaryResult.summary));

      // Extract duration from summary if not in attributes
      final effectiveDuration = duration > 0
          ? duration
          : _extractDurationFromSummary(summaryResult.summary);

      return _DetailsResult(
        entry: ReasoningEntry(
          reasoning: HtmlUtils.unescapeHtml(summaryResult.remaining),
          summary: HtmlUtils.unescapeHtml(summaryResult.summary),
          duration: effectiveDuration,
          isDone: false,
        ),
        endIndex: content.length,
        isComplete: false,
        isReasoning: isReasoning,
      );
    }

    // Complete block
    final closeIdx = i - '</details>'.length;
    final innerContent = content.substring(openTagEnd + 1, closeIdx);
    final summaryResult = _extractSummary(innerContent);

    // Determine if this is reasoning based on type or summary
    final isReasoning =
        type == 'reasoning' ||
        (type.isEmpty &&
            _reasoningSummaryPattern.hasMatch(summaryResult.summary));

    // Extract duration from summary if not in attributes
    final effectiveDuration = duration > 0
        ? duration
        : _extractDurationFromSummary(summaryResult.summary);

    return _DetailsResult(
      entry: ReasoningEntry(
        reasoning: HtmlUtils.unescapeHtml(summaryResult.remaining),
        summary: HtmlUtils.unescapeHtml(summaryResult.summary),
        duration: effectiveDuration,
        isDone: isDone,
      ),
      endIndex: i,
      isComplete: true,
      isReasoning: isReasoning,
    );
  }

  /// Parse a raw reasoning tag pair (e.g., `<think>...</think>`).
  static _ReasoningResult _parseRawReasoning(
    String content,
    int startIdx,
    String startTag,
    String endTag,
  ) {
    final endIdx = content.indexOf(endTag, startIdx + startTag.length);

    if (endIdx == -1) {
      // Incomplete block (streaming)
      final innerContent = content.substring(startIdx + startTag.length);
      return _ReasoningResult(
        entry: ReasoningEntry(
          reasoning: HtmlUtils.unescapeHtml(innerContent.trim()),
          summary: '',
          duration: 0,
          isDone: false,
        ),
        endIndex: content.length,
        isComplete: false,
      );
    }

    // Complete block
    final innerContent = content.substring(startIdx + startTag.length, endIdx);
    return _ReasoningResult(
      entry: ReasoningEntry(
        reasoning: HtmlUtils.unescapeHtml(innerContent.trim()),
        summary: '',
        duration: 0,
        isDone: true,
      ),
      endIndex: endIdx + endTag.length,
      isComplete: true,
    );
  }

  /// Extract `<summary>...</summary>` from content.
  static _SummaryResult _extractSummary(String content) {
    final summaryRegex = RegExp(
      r'^\s*<summary>(.*?)</summary>\s*',
      dotAll: true,
    );
    final match = summaryRegex.firstMatch(content);

    if (match != null) {
      return _SummaryResult(
        summary: (match.group(1) ?? '').trim(),
        remaining: content.substring(match.end).trim(),
      );
    }

    return _SummaryResult(summary: '', remaining: content.trim());
  }

  /// Extract duration from summary text like "Thought (1s)" or "Thinking (2m 30s)".
  static int _extractDurationFromSummary(String summary) {
    // Match patterns like "(1s)", "(30s)", "(1m)", "(2m 30s)", "(1m30s)"
    // Supports minutes-only "(1m)", seconds-only "(30s)", or both "(2m 30s)"
    final durationRegex = RegExp(
      r'\((\d+)m(?:\s*(\d+)s)?\)|\((\d+)s\)',
      caseSensitive: false,
    );
    final match = durationRegex.firstMatch(summary);
    if (match != null) {
      // Check if it's a minutes pattern (groups 1 and 2) or seconds-only (group 3)
      if (match.group(1) != null) {
        // Minutes pattern: "(Xm)" or "(Xm Ys)"
        final minutes = int.tryParse(match.group(1) ?? '0') ?? 0;
        final seconds = int.tryParse(match.group(2) ?? '0') ?? 0;
        return minutes * 60 + seconds;
      } else if (match.group(3) != null) {
        // Seconds-only pattern: "(Xs)"
        return int.tryParse(match.group(3) ?? '0') ?? 0;
      }
    }
    return 0;
  }

  /// Parses a message and extracts the first reasoning content block.
  /// Returns null if no reasoning content is found.
  static ReasoningContent? parseReasoningContent(
    String content, {
    List<(String, String)>? customTagPairs,
    bool detectDefaultTags = true,
  }) {
    final segs = segments(
      content,
      customTagPairs: customTagPairs,
      detectDefaultTags: detectDefaultTags,
    );
    if (segs == null || segs.isEmpty) return null;

    // Find the first reasoning entry
    ReasoningEntry? firstEntry;
    final textParts = <String>[];

    for (final seg in segs) {
      if (seg.isReasoning && firstEntry == null) {
        firstEntry = seg.entry;
      } else if (seg.text != null) {
        textParts.add(seg.text!);
      }
    }

    if (firstEntry == null) return null;

    return ReasoningContent(
      reasoning: firstEntry.reasoning,
      summary: firstEntry.summary,
      duration: firstEntry.duration,
      isDone: firstEntry.isDone,
      mainContent: textParts.join().trim(),
      originalContent: content,
    );
  }

  /// Checks if a message contains reasoning content.
  static bool hasReasoningContent(String content) {
    // Check for <details type="reasoning"
    if (content.contains('type="reasoning"')) return true;

    // Check for <details> with reasoning-like summary
    if (content.contains('<details')) {
      final summaryMatch = RegExp(
        r'<summary>([^<]*)</summary>',
      ).firstMatch(content);
      if (summaryMatch != null) {
        final summary = summaryMatch.group(1) ?? '';
        if (_reasoningSummaryPattern.hasMatch(summary)) return true;
      }
    }

    // Check for raw tag pairs
    for (final pair in defaultReasoningTagPairs) {
      if (content.contains(pair.$1)) return true;
    }

    return false;
  }

  /// Formats the duration for display.
  static String formatDuration(int seconds) {
    if (seconds <= 0) return 'instant';
    if (seconds < 60) return '$seconds second${seconds == 1 ? '' : 's'}';

    final minutes = seconds ~/ 60;
    final remainingSeconds = seconds % 60;

    if (remainingSeconds == 0) {
      return '$minutes minute${minutes == 1 ? '' : 's'}';
    }

    return '$minutes min ${remainingSeconds}s';
  }
}

class _ReasoningResult {
  final ReasoningEntry entry;
  final int endIndex;
  final bool isComplete;

  const _ReasoningResult({
    required this.entry,
    required this.endIndex,
    required this.isComplete,
  });
}

class _DetailsResult {
  final ReasoningEntry entry;
  final int endIndex;
  final bool isComplete;
  final bool isReasoning;

  const _DetailsResult({
    required this.entry,
    required this.endIndex,
    required this.isComplete,
    required this.isReasoning,
  });
}

class _SummaryResult {
  final String summary;
  final String remaining;

  const _SummaryResult({required this.summary, required this.remaining});
}