package parser

import (
	"math"

	"github.com/agext/levenshtein"
)

type MatchBlock struct {
	Start, End int
	Block      Block
	src        *string
}

func (m MatchBlock) GetContent() string {
	if m.src == nil || m.Start < 0 || m.End > len(*m.src) || m.Start > m.End {
		return ""
	}
	return (*m.src)[m.Start:m.End]
}

// MatchBlocksFuzzy finds anchor positions for all BlockMatching blocks using
// Levenshtein distance (tolerant matching), then returns ONLY the BlockData
// segments as gaps between those anchors.
func MatchBlocksFuzzy(markdown string, blocks []Block, maxDist float64) []MatchBlock {
	var out []MatchBlock

	var lastIndex = 0
	for i, b := range blocks {
		if b.Type == BlockMatching {
			start, end := FuzzyFind(markdown, lastIndex, b.GetContent(), 0.3)
			if end != -1 {
				if i > 0 {
					previousBlock := blocks[i-1]
					if previousBlock.Type == BlockData {
						out = append(out, MatchBlock{
							Start: lastIndex,
							End:   start,
							Block: previousBlock,
							src:   &markdown,
						})
					}
				}
				lastIndex = end
			}
		}
	}

	// Handle the last block
	lastBlock := blocks[len(blocks)-1]
	if lastBlock.Type == BlockData {
		out = append(out, MatchBlock{
			Start: lastIndex,
			End:   len(markdown),
			Block: lastBlock,
			src:   &markdown,
		})
	}

	return out
}

func FuzzyFind(haystack string, from int, needle string, maxDist float64) (start int, end int) {
	bestStart, bestEnd, bestDist := -1, -1, math.MaxFloat64
	needleLen := len(needle)
	minWindow := max(1, needleLen-int(float64(needleLen)*maxDist)-1)
	maxWindow := needleLen + int(float64(needleLen)*maxDist) + 1

	for i := from; i < len(haystack); i++ {
		for windowSize := minWindow; windowSize <= maxWindow && i+windowSize <= len(haystack); windowSize++ {
			sub := haystack[i : i+windowSize]
			dist := levenshtein.Distance(sub, needle, nil)
			maxLen := max(needleLen, windowSize)
			norm := float64(dist)/float64(maxLen) + float64(abs(windowSize-needleLen))*0.01/float64(maxLen)

			if norm < bestDist {
				bestStart, bestEnd, bestDist = i, i+windowSize, norm
			}
		}
		if bestDist <= 0.05 {
			break
		}
	}

	if bestStart >= 0 && bestDist <= maxDist+0.01 {
		return bestStart, bestEnd
	}
	return -1, -1
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}