package parser

import (
	"fmt"
	"mermaid-go/pkg/ast"
	"mermaid-go/pkg/detector"
)

// MermaidParser is the main parser that can handle all diagram types
type MermaidParser struct {
	detector *detector.DetectorRegistry
}

// NewMermaidParser creates a new main parser
func NewMermaidParser() *MermaidParser {
	return &MermaidParser{
		detector: detector.NewDetectorRegistry(),
	}
}

// Parse parses mermaid text and returns the appropriate diagram AST
func (p *MermaidParser) Parse(input string) (ast.Diagram, error) {
	// First, detect the diagram type
	diagramType := p.detector.DetectDiagramType(input)

	switch diagramType {
	case detector.DiagramTypeSequence:
		return p.parseSequence(input)
	case detector.DiagramTypeState, detector.DiagramTypeStateV2:
		return p.parseState(input)
	case detector.DiagramTypeFlowchart:
		return p.parseFlowchart(input)
	case detector.DiagramTypeClass:
		return p.parseClass(input)
	case detector.DiagramTypeER:
		return p.parseER(input)
	case detector.DiagramTypeGantt:
		return p.parseGantt(input)
	case detector.DiagramTypePie:
		return p.parsePie(input)
	case detector.DiagramTypeGit:
		return p.parseGit(input)
	case detector.DiagramTypeUserJourney:
		return p.parseUserJourney(input)
	case detector.DiagramTypeTimeline:
		return p.parseTimeline(input)
	case detector.DiagramTypeMindmap:
		return p.parseMindmap(input)
	case detector.DiagramTypeKanban:
		return p.parseKanban(input)
	case detector.DiagramTypeSankey:
		return p.parseSankey(input)
	case detector.DiagramTypeXYChart:
		return p.parseXYChart(input)
	case detector.DiagramTypeQuadrant:
		return p.parseQuadrant(input)
	case detector.DiagramTypeRequirement:
		return p.parseRequirement(input)
	case detector.DiagramTypeBlock:
		return p.parseBlock(input)
	case detector.DiagramTypeC4:
		return p.parseC4(input)
	case detector.DiagramTypeC4Context:
		return p.parseC4(input)
	case detector.DiagramTypeC4Container:
		return p.parseC4(input)
	case detector.DiagramTypeC4Component:
		return p.parseC4(input)
	case detector.DiagramTypeC4Dynamic:
		return p.parseC4(input)
	case detector.DiagramTypeC4Deployment:
		return p.parseC4(input)
	case detector.DiagramTypeArchitecture:
		return p.parseArchitecture(input)
	case detector.DiagramTypeRadar:
		return p.parseRadar(input)
	case detector.DiagramTypeTreemap:
		return p.parseTreemap(input)
	case detector.DiagramTypePacket:
		return p.parsePacket(input)
	case detector.DiagramTypeInfo:
		return p.parseInfo(input)
	case detector.DiagramTypeOrganization:
		return p.parseOrganization(input)
	case detector.DiagramTypeBPMN:
		return p.parseBPMN(input)
	default:
		return nil, fmt.Errorf("unsupported diagram type: %s", diagramType)
	}
}

// GetDiagramType returns the detected diagram type without parsing
func (p *MermaidParser) GetDiagramType(input string) detector.DiagramType {
	return p.detector.DetectDiagramType(input)
}

// parseSequence parses sequence diagrams
func (p *MermaidParser) parseSequence(input string) (ast.Diagram, error) {
	parser := NewSequenceParser()
	return parser.Parse(input)
}

// parseState parses state diagrams
func (p *MermaidParser) parseState(input string) (ast.Diagram, error) {
	parser := NewStateParser()
	return parser.Parse(input)
}

// parseFlowchart parses flowcharts
func (p *MermaidParser) parseFlowchart(input string) (ast.Diagram, error) {
	parser := NewParser()
	return parser.Parse(input)
}

// parseClass parses class diagrams
func (p *MermaidParser) parseClass(input string) (ast.Diagram, error) {
	parser := NewClassParser()
	return parser.Parse(input)
}

// parseER parses ER diagrams
func (p *MermaidParser) parseER(input string) (ast.Diagram, error) {
	parser := NewERParser()
	return parser.Parse(input)
}

// parseGantt parses Gantt charts
func (p *MermaidParser) parseGantt(input string) (ast.Diagram, error) {
	parser := NewGanttParser()
	return parser.Parse(input)
}

// parsePie parses pie charts
func (p *MermaidParser) parsePie(input string) (ast.Diagram, error) {
	parser := NewPieParser()
	return parser.Parse(input)
}

// parseGit parses git graphs
func (p *MermaidParser) parseGit(input string) (ast.Diagram, error) {
	parser := NewGitParser()
	return parser.Parse(input)
}

// parseUserJourney parses user journey diagrams
func (p *MermaidParser) parseUserJourney(input string) (ast.Diagram, error) {
	parser := NewJourneyParser()
	return parser.Parse(input)
}

// parseTimeline parses timeline diagrams
func (p *MermaidParser) parseTimeline(input string) (ast.Diagram, error) {
	parser := NewTimelineParser()
	return parser.Parse(input)
}

// parseMindmap parses mindmaps
func (p *MermaidParser) parseMindmap(input string) (ast.Diagram, error) {
	parser := NewMindmapParser()
	return parser.Parse(input)
}

// parseKanban parses kanban diagrams
func (p *MermaidParser) parseKanban(input string) (ast.Diagram, error) {
	parser := NewKanbanParser()
	return parser.Parse(input)
}

// parseSankey parses Sankey diagrams
func (p *MermaidParser) parseSankey(input string) (ast.Diagram, error) {
	parser := NewSankeyParser()
	return parser.Parse(input)
}

// parseXYChart parses XY charts
func (p *MermaidParser) parseXYChart(input string) (ast.Diagram, error) {
	parser := NewXYChartParser()
	return parser.Parse(input)
}

// parseQuadrant parses quadrant charts
func (p *MermaidParser) parseQuadrant(input string) (ast.Diagram, error) {
	parser := NewQuadrantParser()
	return parser.Parse(input)
}

// parseRequirement parses requirement diagrams (placeholder implementation)
func (p *MermaidParser) parseRequirement(input string) (ast.Diagram, error) {
	// TODO: Implement requirement diagram parser
	return nil, fmt.Errorf("requirement diagram parsing not yet implemented")
}

// parseBlock parses block diagrams (placeholder implementation)
func (p *MermaidParser) parseBlock(input string) (ast.Diagram, error) {
	// TODO: Implement block diagram parser
	return nil, fmt.Errorf("block diagram parsing not yet implemented")
}

// parseC4 parses C4 diagrams
func (p *MermaidParser) parseC4(input string) (ast.Diagram, error) {
	parser := NewC4Parser()
	return parser.Parse(input)
}

// parseArchitecture parses architecture diagrams
func (p *MermaidParser) parseArchitecture(input string) (ast.Diagram, error) {
	parser := NewArchitectureParser()
	return parser.Parse(input)
}

// parseRadar parses radar charts
func (p *MermaidParser) parseRadar(input string) (ast.Diagram, error) {
	parser := NewRadarParser()
	return parser.Parse(input)
}

// parseTreemap parses treemaps
func (p *MermaidParser) parseTreemap(input string) (ast.Diagram, error) {
	parser := NewTreemapParser()
	return parser.Parse(input)
}

// parsePacket parses packet diagrams
func (p *MermaidParser) parsePacket(input string) (ast.Diagram, error) {
	parser := NewPacketParser()
	return parser.Parse(input)
}

// parseInfo parses info diagrams
func (p *MermaidParser) parseInfo(input string) (ast.Diagram, error) {
	parser := NewInfoParser()
	return parser.Parse(input)
}

// parseOrganization parses organization charts
func (p *MermaidParser) parseOrganization(input string) (ast.Diagram, error) {
	parser := NewOrganizationParser()
	return parser.Parse(input)
}

// parseBPMN parses BPMN diagrams
func (p *MermaidParser) parseBPMN(input string) (ast.Diagram, error) {
	parser := NewBPMNParser()
	return parser.Parse(input)
}