package ass

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	"sub-cli/internal/model"
)

func TestParse(t *testing.T) {
	// Create temporary test file
	content := `[Script Info]
ScriptType: v4.00+
Title: Test ASS File
PlayResX: 640
PlayResY: 480

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1
Style: Bold,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,1,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1

[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:00:01.00,0:00:04.00,Default,,0,0,0,,This is the first subtitle line.
Dialogue: 0,0:00:05.00,0:00:08.00,Bold,,0,0,0,,This is the second subtitle line with bold style.
Comment: 0,0:00:09.00,0:00:12.00,Default,,0,0,0,,This is a comment.
`
	tempDir := t.TempDir()
	testFile := filepath.Join(tempDir, "test.ass")
	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}

	// Test parsing
	assFile, err := Parse(testFile)
	if err != nil {
		t.Fatalf("Parse failed: %v", err)
	}

	// Verify results
	// Script info
	if assFile.ScriptInfo["Title"] != "Test ASS File" {
		t.Errorf("Title mismatch: expected 'Test ASS File', got '%s'", assFile.ScriptInfo["Title"])
	}
	if assFile.ScriptInfo["ScriptType"] != "v4.00+" {
		t.Errorf("Script type mismatch: expected 'v4.00+', got '%s'", assFile.ScriptInfo["ScriptType"])
	}

	// Styles
	if len(assFile.Styles) != 3 {
		t.Errorf("Expected 3 styles, got %d", len(assFile.Styles))
	} else {
		// Find Bold style
		var boldStyle *model.ASSStyle
		for i, style := range assFile.Styles {
			if style.Name == "Bold" {
				boldStyle = &assFile.Styles[i]
				break
			}
		}
		
		if boldStyle == nil {
			t.Errorf("Bold style not found")
		} else {
			boldValue, exists := boldStyle.Properties["Bold"]
			if !exists || boldValue != "1" {
				t.Errorf("Bold style Bold property mismatch: expected '1', got '%s'", boldValue)
			}
		}
	}

	// Events
	if len(assFile.Events) != 3 {
		t.Errorf("Expected 3 events, got %d", len(assFile.Events))
	} else {
		// Check first dialogue line
		if assFile.Events[0].Type != "Dialogue" {
			t.Errorf("First event type mismatch: expected 'Dialogue', got '%s'", assFile.Events[0].Type)
		}
		if assFile.Events[0].StartTime.Seconds != 1 || assFile.Events[0].StartTime.Milliseconds != 0 {
			t.Errorf("First event start time mismatch: expected 00:00:01.00, got %d:%02d:%02d.%03d",
				assFile.Events[0].StartTime.Hours, assFile.Events[0].StartTime.Minutes,
				assFile.Events[0].StartTime.Seconds, assFile.Events[0].StartTime.Milliseconds)
		}
		if assFile.Events[0].Text != "This is the first subtitle line." {
			t.Errorf("First event text mismatch: expected 'This is the first subtitle line.', got '%s'", assFile.Events[0].Text)
		}

		// Check second dialogue line (bold style)
		if assFile.Events[1].Style != "Bold" {
			t.Errorf("Second event style mismatch: expected 'Bold', got '%s'", assFile.Events[1].Style)
		}

		// Check comment line
		if assFile.Events[2].Type != "Comment" {
			t.Errorf("Third event type mismatch: expected 'Comment', got '%s'", assFile.Events[2].Type)
		}
	}
}

func TestGenerate(t *testing.T) {
	// Create test ASS file structure
	assFile := model.NewASSFile()
	assFile.ScriptInfo["Title"] = "Generation Test"
	
	// Add a custom style
	boldStyle := model.ASSStyle{
		Name: "Bold",
		Properties: map[string]string{
			"Format": "Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding",
			"Style": "Bold,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,1,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1",
			"Bold": "1",
		},
	}
	assFile.Styles = append(assFile.Styles, boldStyle)
	
	// Add two dialogue events
	event1 := model.NewASSEvent()
	event1.StartTime = model.Timestamp{Seconds: 1}
	event1.EndTime = model.Timestamp{Seconds: 4}
	event1.Text = "This is the first line."
	
	event2 := model.NewASSEvent()
	event2.StartTime = model.Timestamp{Seconds: 5}
	event2.EndTime = model.Timestamp{Seconds: 8}
	event2.Style = "Bold"
	event2.Text = "This is the second line with bold style."
	
	assFile.Events = append(assFile.Events, event1, event2)
	
	// Generate ASS file
	tempDir := t.TempDir()
	outputFile := filepath.Join(tempDir, "output.ass")
	err := Generate(assFile, outputFile)
	if err != nil {
		t.Fatalf("Generation failed: %v", err)
	}
	
	// Verify generated content
	content, err := os.ReadFile(outputFile)
	if err != nil {
		t.Fatalf("Failed to read output file: %v", err)
	}
	
	contentStr := string(content)
	
	// Check script info
	if !strings.Contains(contentStr, "Title: Generation Test") {
		t.Errorf("Output file should contain title 'Title: Generation Test'")
	}
	
	// Check styles
	if !strings.Contains(contentStr, "Style: Bold,Arial,20") {
		t.Errorf("Output file should contain Bold style")
	}
	
	// Check dialogue lines
	if !strings.Contains(contentStr, "Dialogue: 0,0:00:01.00,0:00:04.00,Default") {
		t.Errorf("Output file should contain first dialogue line")
	}
	if !strings.Contains(contentStr, "This is the first line.") {
		t.Errorf("Output file should contain first line text")
	}
	
	if !strings.Contains(contentStr, "Dialogue: 0,0:00:05.00,0:00:08.00,Bold") {
		t.Errorf("Output file should contain second dialogue line")
	}
	if !strings.Contains(contentStr, "This is the second line with bold style.") {
		t.Errorf("Output file should contain second line text")
	}
}

func TestFormat(t *testing.T) {
	// Create test file (intentionally with mixed formatting)
	content := `[Script Info]
ScriptType:v4.00+
  Title:   Formatting Test

[V4+ Styles]
Format:Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style:Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1

[Events]
Format:Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue:0,0:0:1.0,0:0:4.0,Default,,0,0,0,,Text before formatting.
`
	tempDir := t.TempDir()
	testFile := filepath.Join(tempDir, "format_test.ass")
	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	
	// Test formatting
	err := Format(testFile)
	if err != nil {
		t.Fatalf("Formatting failed: %v", err)
	}
	
	// Verify formatted file
	formattedContent, err := os.ReadFile(testFile)
	if err != nil {
		t.Fatalf("Failed to read formatted file: %v", err)
	}
	
	formattedStr := string(formattedContent)
	
	// Check formatting
	if !strings.Contains(formattedStr, "ScriptType: v4.00+") {
		t.Errorf("Formatted file should contain standardized ScriptType line")
	}
	
	if !strings.Contains(formattedStr, "Title: Formatting Test") {
		t.Errorf("Formatted file should contain standardized Title line")
	}
	
	// Check timestamp formatting
	if !strings.Contains(formattedStr, "0:00:01.00,0:00:04.00") {
		t.Errorf("Formatted file should contain standardized timestamp format (0:00:01.00,0:00:04.00)")
	}
}

func TestConvertToSubtitle(t *testing.T) {
	// Create test file
	content := `[Script Info]
ScriptType: v4.00+
Title: Conversion Test

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1
Style: Bold,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,1,0,0,0,100,100,0,0,1,2,2,2,10,10,10,1
Style: Italic,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,1,0,0,100,100,0,0,1,2,2,2,10,10,10,1

[Events]
Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:00:01.00,0:00:04.00,Default,,0,0,0,,Normal text.
Dialogue: 0,0:00:05.00,0:00:08.00,Bold,,0,0,0,,Bold text.
Dialogue: 0,0:00:09.00,0:00:12.00,Italic,,0,0,0,,Italic text.
`
	tempDir := t.TempDir()
	testFile := filepath.Join(tempDir, "convert_test.ass")
	if err := os.WriteFile(testFile, []byte(content), 0644); err != nil {
		t.Fatalf("Failed to create test file: %v", err)
	}
	
	// Convert to subtitle
	subtitle, err := ConvertToSubtitle(testFile)
	if err != nil {
		t.Fatalf("Conversion failed: %v", err)
	}
	
	// Verify results
	if subtitle.Format != "ass" {
		t.Errorf("Expected format 'ass', got '%s'", subtitle.Format)
	}
	
	if subtitle.Metadata["Title"] != "Conversion Test" {
		t.Errorf("Expected title 'Conversion Test', got '%s'", subtitle.Metadata["Title"])
	}
	
	if len(subtitle.Entries) != 3 {
		t.Errorf("Expected 3 entries, got %d", len(subtitle.Entries))
	} else {
		// Check first entry
		if subtitle.Entries[0].Text != "Normal text." {
			t.Errorf("First entry text mismatch: expected 'Normal text.', got '%s'", subtitle.Entries[0].Text)
		}
		
		// Check second entry (bold)
		if subtitle.Entries[1].Text != "Bold text." {
			t.Errorf("Second entry text mismatch: expected 'Bold text.', got '%s'", subtitle.Entries[1].Text)
		}
		bold, ok := subtitle.Entries[1].Styles["bold"]
		if !ok || bold != "true" {
			t.Errorf("Second entry should have bold=true style")
		}
		
		// Check third entry (italic)
		if subtitle.Entries[2].Text != "Italic text." {
			t.Errorf("Third entry text mismatch: expected 'Italic text.', got '%s'", subtitle.Entries[2].Text)
		}
		italic, ok := subtitle.Entries[2].Styles["italic"]
		if !ok || italic != "true" {
			t.Errorf("Third entry should have italic=true style")
		}
	}
}

func TestConvertFromSubtitle(t *testing.T) {
	// Create test subtitle
	subtitle := model.NewSubtitle()
	subtitle.Format = "ass"
	subtitle.Title = "Conversion from Subtitle Test"
	
	// Create a normal entry
	entry1 := model.NewSubtitleEntry()
	entry1.Index = 1
	entry1.StartTime = model.Timestamp{Seconds: 1}
	entry1.EndTime = model.Timestamp{Seconds: 4}
	entry1.Text = "Normal text."
	
	// Create a bold entry
	entry2 := model.NewSubtitleEntry()
	entry2.Index = 2
	entry2.StartTime = model.Timestamp{Seconds: 5}
	entry2.EndTime = model.Timestamp{Seconds: 8}
	entry2.Text = "Bold text."
	entry2.Styles["bold"] = "true"
	
	// Create an italic entry
	entry3 := model.NewSubtitleEntry()
	entry3.Index = 3
	entry3.StartTime = model.Timestamp{Seconds: 9}
	entry3.EndTime = model.Timestamp{Seconds: 12}
	entry3.Text = "Italic text."
	entry3.Styles["italic"] = "true"
	
	subtitle.Entries = append(subtitle.Entries, entry1, entry2, entry3)
	
	// Convert from subtitle
	tempDir := t.TempDir()
	outputFile := filepath.Join(tempDir, "convert_from_subtitle.ass")
	err := ConvertFromSubtitle(subtitle, outputFile)
	if err != nil {
		t.Fatalf("Conversion failed: %v", err)
	}
	
	// Verify converted ASS file
	assFile, err := Parse(outputFile)
	if err != nil {
		t.Fatalf("Failed to parse converted file: %v", err)
	}
	
	// Check script info
	if assFile.ScriptInfo["Title"] != "Conversion from Subtitle Test" {
		t.Errorf("Expected title 'Conversion from Subtitle Test', got '%s'", assFile.ScriptInfo["Title"])
	}
	
	// Check events
	if len(assFile.Events) != 3 {
		t.Errorf("Expected 3 events, got %d", len(assFile.Events))
	} else {
		// Check first dialogue line
		if assFile.Events[0].Text != "Normal text." {
			t.Errorf("First event text mismatch: expected 'Normal text.', got '%s'", assFile.Events[0].Text)
		}
		
		// Check second dialogue line (bold)
		if assFile.Events[1].Text != "Bold text." {
			t.Errorf("Second event text mismatch: expected 'Bold text.', got '%s'", assFile.Events[1].Text)
		}
		if assFile.Events[1].Style != "Bold" {
			t.Errorf("Second event should use Bold style, got '%s'", assFile.Events[1].Style)
		}
		
		// Check third dialogue line (italic)
		if assFile.Events[2].Text != "Italic text." {
			t.Errorf("Third event text mismatch: expected 'Italic text.', got '%s'", assFile.Events[2].Text)
		}
		if assFile.Events[2].Style != "Italic" {
			t.Errorf("Third event should use Italic style, got '%s'", assFile.Events[2].Style)
		}
	}
	
	// Check styles
	styleNames := make(map[string]bool)
	for _, style := range assFile.Styles {
		styleNames[style.Name] = true
	}
	
	if !styleNames["Bold"] {
		t.Errorf("Should contain Bold style")
	}
	if !styleNames["Italic"] {
		t.Errorf("Should contain Italic style")
	}
}

func TestParse_EdgeCases(t *testing.T) {
	// Test empty file
	tempDir := t.TempDir()
	emptyFile := filepath.Join(tempDir, "empty.ass")
	if err := os.WriteFile(emptyFile, []byte{}, 0644); err != nil {
		t.Fatalf("Failed to create empty test file: %v", err)
	}
	
	assFile, err := Parse(emptyFile)
	if err != nil {
		t.Fatalf("Failed to parse empty file: %v", err)
	}
	
	if len(assFile.Events) != 0 {
		t.Errorf("Empty file should have 0 events, got %d", len(assFile.Events))
	}
	
	// Test file missing required sections
	malformedContent := `[Script Info]
Title: Missing Sections Test
`
	malformedFile := filepath.Join(tempDir, "malformed.ass")
	if err := os.WriteFile(malformedFile, []byte(malformedContent), 0644); err != nil {
		t.Fatalf("Failed to create malformed file: %v", err)
	}
	
	assFile, err = Parse(malformedFile)
	if err != nil {
		t.Fatalf("Failed to parse malformed file: %v", err)
	}
	
	if assFile.ScriptInfo["Title"] != "Missing Sections Test" {
		t.Errorf("Should correctly parse the title")
	}
	if len(assFile.Events) != 0 {
		t.Errorf("File missing Events section should have 0 events")
	}
}

func TestParse_FileError(t *testing.T) {
	// Test non-existent file
	_, err := Parse("/nonexistent/file.ass")
	if err == nil {
		t.Error("Parsing non-existent file should return an error")
	}
}

func TestGenerate_FileError(t *testing.T) {
	// Test invalid path
	assFile := model.NewASSFile()
	err := Generate(assFile, "/nonexistent/directory/file.ass")
	if err == nil {
		t.Error("Generating to invalid path should return an error")
	}
}

func TestConvertToSubtitle_FileError(t *testing.T) {
	// Test non-existent file
	_, err := ConvertToSubtitle("/nonexistent/file.ass")
	if err == nil {
		t.Error("Converting non-existent file should return an error")
	}
}

func TestConvertFromSubtitle_FileError(t *testing.T) {
	// Test invalid path
	subtitle := model.NewSubtitle()
	err := ConvertFromSubtitle(subtitle, "/nonexistent/directory/file.ass")
	if err == nil {
		t.Error("Converting to invalid path should return an error")
	}
}

func TestParseASSTimestamp(t *testing.T) {
	testCases := []struct {
		name     string
		input    string
		expected model.Timestamp
	}{
		{
			name:     "Standard format",
			input:    "0:00:01.00",
			expected: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
		},
		{
			name:     "With centiseconds",
			input:    "0:00:01.50",
			expected: model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 500},
		},
		{
			name:     "Complete hours, minutes, seconds",
			input:    "1:02:03.45",
			expected: model.Timestamp{Hours: 1, Minutes: 2, Seconds: 3, Milliseconds: 450},
		},
		{
			name:     "Invalid format",
			input:    "invalid",
			expected: model.Timestamp{},
		},
	}
	
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result := parseASSTimestamp(tc.input)
			if result != tc.expected {
				t.Errorf("For input '%s', expected %+v, got %+v", tc.input, tc.expected, result)
			}
		})
	}
}

func TestFormatASSTimestamp(t *testing.T) {
	testCases := []struct {
		name     string
		input    model.Timestamp
		expected string
	}{
		{
			name:     "Zero timestamp",
			input:    model.Timestamp{},
			expected: "0:00:00.00",
		},
		{
			name:     "Simple seconds",
			input:    model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 0},
			expected: "0:00:01.00",
		},
		{
			name:     "With milliseconds",
			input:    model.Timestamp{Hours: 0, Minutes: 0, Seconds: 1, Milliseconds: 500},
			expected: "0:00:01.50",
		},
		{
			name:     "Complete timestamp",
			input:    model.Timestamp{Hours: 1, Minutes: 2, Seconds: 3, Milliseconds: 450},
			expected: "1:02:03.45",
		},
	}
	
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			result := formatASSTimestamp(tc.input)
			if result != tc.expected {
				t.Errorf("For timestamp %+v, expected '%s', got '%s'", tc.input, tc.expected, result)
			}
		})
	}
}