package main

import "sort"

// a MatchIndex represents a match/group. It contains the start index and end index of the match
type MatchIndex struct {
	startIdx int
	endIdx   int
}

// A Match represents multiple matchIndices. Specifically, it maps an integer (representing the capturing group)
// to the matchIndex of that group.
// Group 0 corresponds to the entire match.
type Match map[int]MatchIndex

// takeZeroState takes the 0-state (if such a transition exists) for all states in the
// given slice. It returns the resulting states. If any of the resulting states is a 0-state,
// the second parameter is true.
func takeZeroState(states []*State) (rtv []*State, isZero bool) {
	for _, state := range states {
		if len(state.transitions[EPSILON]) > 0 {
			rtv = append(rtv, state.transitions[EPSILON]...)
		}
	}
	for _, state := range rtv {
		if len(state.transitions[EPSILON]) > 0 {
			return rtv, true
		}
	}
	return rtv, false
}

// zeroMatchPossible returns true if a zero-length match is possible
// from any of the given states.
// It uses the same algorithm to find zero-states as the one inside the loop,
// so I should probably put it in a function.
func zeroMatchPossible(states ...*State) bool {
	zerostates, iszero := takeZeroState(states)
	tempstates := make([]*State, 0, len(zerostates)+len(states))
	tempstates = append(tempstates, states...)
	tempstates = append(tempstates, zerostates...)
	num_appended := 0 // number of unique states addded to tempstates
	for iszero == true {
		zerostates, iszero = takeZeroState(tempstates)
		tempstates, num_appended = unique_append(tempstates, zerostates...)
		if num_appended == 0 { // break if we haven't appended any more unique values
			break
		}
	}
	for _, state := range tempstates {
		if state.isEmpty && state.assert == NONE && state.isLast {
			return true
		}
	}
	return false
}

// Prunes the slice by removing overlapping indices.
func pruneIndices(indices []MatchIndex) []MatchIndex {
	// First, sort the slice by the start indices
	sort.Slice(indices, func(i, j int) bool {
		return indices[i].startIdx < indices[j].startIdx
	})
	toRet := make([]MatchIndex, 0, len(indices))
	current := indices[0]
	for _, idx := range indices[1:] {
		// idx doesn't overlap with current (starts after current ends), so add current to result
		// and update the current.
		if idx.startIdx >= current.endIdx {
			toRet = append(toRet, current)
			current = idx
		} else if idx.endIdx > current.endIdx {
			// idx overlaps, but it is longer, so update current
			current = idx
		}
	}
	// Add last state
	toRet = append(toRet, current)
	return toRet
}

// findAllMatches tries to find all matches of the regex represented by given start-state, with
// the given string
func findAllMatches(start *State, str []rune) []MatchIndex {
	idx := 0
	var matchFound bool
	var matchIdx MatchIndex
	indices := new_uniq_arr[MatchIndex]()
	for idx <= len(str) {
		matchFound, matchIdx, idx = findAllMatchesHelper(start, str, idx)
		if matchFound {
			indices.add(matchIdx)
		}
	}
	toReturn := indices.values()
	if len(toReturn) > 0 {
		return pruneIndices(toReturn)
	}
	return toReturn
}

// Helper for findAllMatches. Returns whether it found a match, the
// first matchIndex it finds, and how far it got into the string ie. where
// the next search should start from.
//
//	Might return duplicates or overlapping indices, so care must be taken to prune the resulting array.
func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchIndex, int) {
	// Base case - exit if offset exceeds string's length
	if offset > len(str) {
		// The first value here shouldn't be used, because we should exit when the second return value is > than len(str)
		return false, MatchIndex{}, offset
	}
	// 'Base case' - if we are at the end of the string, check if we can add a zero-length match
	if offset == len(str) {
		// Get all zero-state matches. If we can get to a zero-state without matching anything, we
		// can add a zero-length match. This is all true only if the start state itself matches nothing.
		if start.isEmpty && start.assert == NONE {
			if zeroMatchPossible(start) {
				return true, MatchIndex{offset, offset}, offset + 1
			}
		}
		return false, MatchIndex{}, offset + 1
	}

	foundPath := false
	startIdx := offset
	endIdx := offset
	currentStates := make([]*State, 0)
	tempStates := make([]*State, 0) // Used to store states that should be used in next loop iteration
	i := offset                     // Index in string
	startingFrom := i               // Store starting index

	// Increment until we hit a character matching the start state (assuming not 0-state)
	if start.isEmpty == false {
		for i < len(str) && !start.contentContains(str, i) {
			i++
		}
		startIdx = i
		startingFrom = i
		i++ // Advance to next character (if we aren't at a 0-state, which doesn't match anything), so that we can check for transitions. If we advance at a 0-state, we will never get a chance to match the first character
	}
	currentStates = append(currentStates, start)

	// Hold a list of match indices for the current run. When we
	// can no longer find a match, the match with the largest range is
	// chosen as the match for the entire string.
	// This allows us to pick the longest possible match (which is how greedy matching works).
	tempIndices := make([]MatchIndex, 0)
	// Main loop
	for i < len(str) {
		foundPath = false

		zeroStates := make([]*State, 0)
		// Keep taking zero-states, until there are no more left to take
		// Objective: If any of our current states have transitions to 0-states, replace them with the 0-state. Do this until there are no more transitions to 0-states, or there are no more unique 0-states to take.
		zeroStates, isZero := takeZeroState(currentStates)
		tempStates = append(tempStates, zeroStates...)
		num_appended := 0
		for isZero == true {
			zeroStates, isZero = takeZeroState(tempStates)
			tempStates, num_appended = unique_append(tempStates, zeroStates...)
			if num_appended == 0 { // Break if we haven't appended any more unique values
				break
			}
		}

		currentStates, _ = unique_append(currentStates, tempStates...)
		tempStates = nil

		// Take any transitions corresponding to current character
		numStatesMatched := 0    // The number of states which had at least 1 match for this round
		assertionFailed := false // Whether or not an assertion failed for this round
		for _, state := range currentStates {
			matches, numMatches := state.matchesFor(str, i)
			if numMatches > 0 {
				numStatesMatched++
				tempStates = append(tempStates, matches...)
				foundPath = true
			}
			if numMatches < 0 {
				assertionFailed = true
			}
			if state.isLast {
				endIdx = i
				tempIndices, _ = unique_append(tempIndices, MatchIndex{startIdx, endIdx})
			}
		}
		if assertionFailed && numStatesMatched == 0 { // Nothing has matched and an assertion has failed - abort
			if i == startingFrom {
				i++
			}
			return false, MatchIndex{}, i
		}
		// Check if we can find a zero-length match
		if foundPath == false {
			if zeroMatchPossible(currentStates...) {
				tempIndices, _ = unique_append(tempIndices, MatchIndex{startIdx, startIdx})
			}
			// If we haven't moved in the string, increment the counter by 1
			// to ensure we don't keep trying the same string over and over.
			//			if i == startingFrom {
			startIdx++
			//	i++
			//			}
			// Get the maximum index-range from the list
			if len(tempIndices) > 0 {
				indexToAdd := Reduce(tempIndices, func(i1 MatchIndex, i2 MatchIndex) MatchIndex {
					r1 := i1.endIdx - i1.startIdx
					r2 := i2.endIdx - i2.startIdx
					if r1 >= r2 {
						return i1
					}
					return i2
				})
				if indexToAdd.startIdx == indexToAdd.endIdx { // If we have a zero-length match, we have to shift the index at which we start. Otherwise we keep looking at the same paert of the string over and over.
					return true, indexToAdd, indexToAdd.endIdx + 1
				} else {
					return true, indexToAdd, indexToAdd.endIdx
				}
			}
			return false, MatchIndex{}, startIdx
		}
		currentStates = make([]*State, len(tempStates))
		copy(currentStates, tempStates)
		tempStates = nil

		i++
	}

	// End-of-string reached. Go to any 0-states, until there are no more 0-states to go to. Then check if any of our states are in the end position.
	// This is the exact same algorithm used inside the loop, so I should probably put it in a function.
	zeroStates, isZero := takeZeroState(currentStates)
	tempStates = append(tempStates, zeroStates...)
	num_appended := 0 // Number of unique states addded to tempStates
	for isZero == true {
		zeroStates, isZero = takeZeroState(tempStates)
		tempStates, num_appended = unique_append(tempStates, zeroStates...)
		if num_appended == 0 { // Break if we haven't appended any more unique values
			break
		}
	}

	currentStates = append(currentStates, tempStates...)
	tempStates = nil

	for _, state := range currentStates {
		// Only add the match if the start index is in bounds. If the state has an assertion,
		// make sure the assertion checks out.
		if state.isLast && startIdx < len(str) {
			if state.assert == NONE || state.checkAssertion(str, len(str)) {
				endIdx = i
				tempIndices, _ = unique_append(tempIndices, MatchIndex{startIdx, endIdx})
			}
		}
	}
	// Get the maximum index-range from the list
	if len(tempIndices) > 0 {
		indexToAdd := Reduce(tempIndices, func(i1 MatchIndex, i2 MatchIndex) MatchIndex {
			r1 := i1.endIdx - i1.startIdx
			r2 := i2.endIdx - i2.startIdx
			if r1 >= r2 {
				return i1
			}
			return i2
		})
		if indexToAdd.endIdx == indexToAdd.startIdx { // Same statement occurs above, see reasoning there
			return true, indexToAdd, indexToAdd.endIdx + 1
		} else {
			return true, indexToAdd, indexToAdd.endIdx
		}
	}
	if startIdx == startingFrom { // Increment starting index if we haven't moved in the string. Prevents us from matching the same part of the string over and over.
		startIdx++
	}
	return false, MatchIndex{}, startIdx
}