class GenerateCantusFirmus:
    #for our constructor function, if no default length or mode is given, generate a random one
    def __init__(self, length: int = None, mode: ModeOption = None, octave: int = 4):
        self._mode = mode or MODES_BY_INDEX[math.floor(random() * 6)]
        self._length = length or 8 + math.floor(random() * 5) #todo: replace with normal distribution
        self._octave = octave
        self._mr = ModeResolver(self._mode)
        
    def generate_cf(self, range_option: RangeOption = RangeOption.TENOR) -> CantusFirmus:
        run_count = 1
        self._solutions = []
        self._initialize_cf(range_option)
        self._backtrack_cf()
        while len(self._solutions) == 0 and run_count < 100:
            run_count += 1
            self._initialize_cf(range_option)
            self._backtrack_cf()
        self._solutions = sorted(self._solutions, key = self._steps_are_proportional)
        if len(self._solutions) > 0:
            for i, note in enumerate(self._solutions[0]):
                self._cf.insert_note(note, i)
            return self._cf
        else: return None
        
    def _steps_are_proportional(self, solution: list[Note]) -> int:
        steps = 0
        for i in range(1, len(solution)):
            if abs(solution[i - 1].get_scale_degree_interval(solution[i])) == 2:
                steps += 1
        proportion = steps / (len(solution) - 1)
        return abs(proportion - AVERAGE_STEPS_PERCENTAGE)

    def _initialize_cf(self, range_option: RangeOption):
        self._mr = ModeResolver(self._mode, range_option)
        self._cf = CantusFirmus(self._length, self._mr, self._octave)
        #"final" is equal to the mode's starting scale degree.  All notes in the cantus firmus will be whole notes
        final = Note(self._mode.value["starting"], self._octave, 8) 
        last_note = Note(self._mode.value["starting"], self._octave, 16) 
        while self._mr.get_lowest().get_scale_degree_interval(final) > 8:
            final = self._mr.get_default_note_from_interval(final, -8)
            last_note = self._mr.get_default_note_from_interval(final, -8)
        while self._mr.get_lowest().get_scale_degree_interval(final) < 0:
            final = self._mr.get_default_note_from_interval(final, 8)
            last_note = self._mr.get_default_note_from_interval(final, 8)
        last_note.set_duration(16)
        #add the "final" to the first and last pitches 
        self._cf.insert_note(final, 0)
        self._cf.insert_note(last_note, self._length - 1)
        #find all notes eligible to be highest note
        possible_highest_notes = []
        for interval in VALID_MELODIC_INTERVALS_SCALE_DEGREES:
            if interval > 1:
                possible_highest_notes += self._get_notes_from_interval(final, interval)
        #filter out two particular cases (highest note can't be B natural in Dorian and can't be F in Phrygian)
        def remove_edge_cases(tpl: tuple) -> bool:
            note = tpl[1]
            if self._mode == ModeOption.PHRYGIAN and note.get_scale_degree() == 4: 
                return False
            if self._mode == ModeOption.DORIAN and note.get_scale_degree() == 7 and note.get_accidental() == ScaleOption.NATURAL:
                return False
            return True
        possible_highest_notes = list(filter(remove_edge_cases, possible_highest_notes))
        
        final_to_highest_interval, highest_note = possible_highest_notes[math.floor(random() * len(possible_highest_notes)) ]
        #based on the highest we've chosen, find possible lowest notes
        possible_lowest_notes = []
        for interval in GET_POSSIBLE_INTERVALS_TO_LOWEST[final_to_highest_interval]:
            possible_lowest_notes += self._get_notes_from_interval(final, interval)
        #remove candidates that form tritones or cross relations with highest note (sevenths are permissible)
        def check_range_interval(tpl: tuple) -> bool:
            note = tpl[1]
            if highest_note.get_chromatic_with_octave() - note.get_chromatic_with_octave() in [6, 11, 13]:
                return False 
            return True
        possible_lowest_notes = list(filter(check_range_interval, possible_lowest_notes))
        final_to_lowest_interval, lowest_note = possible_lowest_notes[math.floor(random() * len(possible_lowest_notes))]
        #note that we exclude the highest interval when calculating possible valid notes since highest note can only appear once
        valid_intervals_from_final = list(range(1, final_to_highest_interval)) 
        if final_to_lowest_interval < 0: valid_intervals_from_final += list(range(final_to_lowest_interval, -1)) 
        valid_pitches = []
        for interval in valid_intervals_from_final:
            valid_pitches += self._get_notes_from_interval(final, interval)
        self._valid_pitches = list(map(lambda tpl: tpl[1], valid_pitches))

        #see whether it's possible to end Cantus Firmus from below (either by step or from the "dominant")
        final_to_dom_interval = -4 if self._mode.value["most_common"] == 5 else -5
        can_end_from_dominant = final_to_dom_interval >= final_to_lowest_interval
        can_end_from_step_below = final_to_lowest_interval <= -2

        #set penultimate note as a step above the final as default
        final_to_penult_interval, penult_note = self._get_notes_from_interval(final, 2)[0]
        if random() > .9: #note that in no cases do we need to worry about b-flat vs b-natural here
            if can_end_from_dominant:
                final_to_penult_interval, penult_note = self._get_notes_from_interval(final, final_to_dom_interval)[0]
            elif can_end_from_step_below:
                final_to_penult_interval, penult_note = self._get_notes_from_interval(final, -2)[0]
        if self._mode == ModeOption.PHRYGIAN:
            penult_note = self._mr.get_default_note_from_interval(last_note, -5)


        #insert the penultimate note into the Cantus Firmus
        self._cf.insert_note(penult_note, self._length - 2)

        #initialize remaining indices
        remaining_indices = [i for i in range(1, self._length - 2)]
        remaining_indices.reverse()
        self._remaining_indices = remaining_indices

        #if we haven't already added the highest note, add it:
        if final_to_penult_interval != final_to_highest_interval:
            self._add_highest(highest_note)
        
        #if we haven't already added the lowest note, add it:
        if final_to_lowest_interval != final_to_penult_interval and final_to_lowest_interval != 1:
            self._add_lowest(lowest_note)

    def _valid_melodic_interval(self, first_note: Note, second_note: Note) -> bool:
        scale_interval = first_note.get_scale_degree_interval(second_note)
        chro_interval = first_note.get_chromatic_interval(second_note)
        if scale_interval not in VALID_MELODIC_INTERVALS_SCALE_DEGREES: return False 
        if chro_interval not in VALID_MELODIC_INTERVALS_CHROMATIC: return False
        return True

    #inserts the highest note into a random unoccupied place in the Cantus Firmus that is not the center
    def _add_highest(self, note: Note) -> None:
        def remove_center_position(index: int) -> bool:
            if self._length % 2 == 1 and index == math.floor(self._length / 2):
                return False 
            return True
        possible_indices = list(filter(remove_center_position, [num for num in self._remaining_indices]))
        shuffle(possible_indices)
        correct_index = None
        for index in possible_indices:
            correct_index = index
            prev_note = self._cf.get_note(index - 1)
            next_note = self._cf.get_note(index + 1)
            if prev_note is None and next_note is None:
                break
            if prev_note is not None and self._valid_melodic_interval(prev_note, note):
                break 
            if prev_note is not None and not self._valid_melodic_interval(prev_note, note):
                continue 
            if next_note is not None and not self._valid_melodic_interval(note, next_note):
                continue
            if next_note is not None and self._valid_melodic_interval(note, next_note):
                #we need to check if the final three notes are handled correctly
                if note.get_scale_degree_interval(next_note) == -2:
                    break 
                #if we leap down, this can't be followed by a downward step
                final = self._cf.get_note(index + 2)
                if next_note.get_scale_degree_interval(final) == -2:
                    continue
                #otherwise we're legal
                break 
        self._cf.insert_note(note, correct_index)
        self._remaining_indices.remove(correct_index)


    def _add_lowest(self, note: Note) -> None:
        possible_indices = [num for num in self._remaining_indices]
        shuffle(possible_indices)
        correct_index = None
        for index in possible_indices:
            #for each index, there are several scenarios:
            #index is preceded by a note (either the highest or the lowest)
            #index is followed by a note (either the highest followed by a blank, the penultimate, or the highest followed by penultimate)
            correct_index = index
            prev_note = self._cf.get_note(index - 1)
            next_note = self._cf.get_note(index + 1)
            note_after_next = self._cf.get_note(index + 2)
            if prev_note is None and next_note is None:
                break
            if prev_note is not None and not self._valid_melodic_interval(prev_note, note):
                continue 
            if next_note is not None and not self._valid_melodic_interval(note, next_note):
                continue
            if next_note is None or note_after_next is None:
                break
            if next_note is not None and note_after_next is not None: #we are in the third to last or fourth to last position
                if index == self._length - 3:
                    #if index is the antipenultimate position, there are no scenarios in which
                    #lowest note -> penultimate -> final have an improper sequence of intervals
                    break 
                #otherwise we need to make sure that a leap to the highest note is handled properly
                final = self._cf.get_note(index + 3)
                lowest_to_highest = note.get_scale_degree_interval(next_note)
                lowest_to_penult = note.get_scale_degree_interval(note_after_next)
                lowest_to_final = note.get_scale_degree_interval(final)
                if lowest_to_highest > 3 and lowest_to_penult != lowest_to_highest - 1 and lowest_to_final != lowest_to_highest - 1:
                    continue
                else:
                    break
        self._cf.insert_note(note, correct_index)
        self._remaining_indices.remove(correct_index)

    def _backtrack_cf(self) -> None:
        if len(self._remaining_indices) == 0:
            solution = []
            for i in range(self._length):
                solution.append(self._cf.get_note(i))
            if self._ascending_intervals_are_handled(solution) and self._no_intervalic_sequences(solution):
                self._solutions.append(solution) 
            return
        index = self._remaining_indices.pop()
        prev_note = self._cf.get_note(index - 1) #will never be None
        next_note = self._cf.get_note(index + 1) #may be None
        def intervals_are_valid(possible_note: Note) -> bool:
            if not self._valid_melodic_interval(prev_note, possible_note): return False 
            if next_note is not None and not self._valid_melodic_interval(possible_note, next_note): return False 
            return True
        possible_pitches = list(filter(intervals_are_valid, self._valid_pitches))
        possible_pitches = sorted(possible_pitches, key = lambda n: abs(prev_note.get_chromatic_interval(n)))
        for possible_note in possible_pitches:
            self._cf.insert_note(possible_note, index)
            if self._current_chain_is_legal():
                self._backtrack_cf()
            self._cf.insert_note(None, index)

        self._remaining_indices.append(index)

    def _current_chain_is_legal(self) -> bool:
        #check for the following:
        #1. no dissonant intervals outlined in "segments" (don't check last segment)
        #2. no dissonant intervals outlined in "leap chains"
        #3. ascending minor sixths followed by descending minor seconds
        #4. in each segment, intervals must become progressively smaller (3 -> 2 or -2 -> -3, etc)
        #5. check if ascending leaps greater than a fourth are followed by descending second (to high degree of proability)
        #6. make sure there are no sequences of two notes that are immediately repeated
        #7. check for cross relations

        #keep track of whether we have a b-flat or b-natural
        has_b_natural = False
        has_b_flat = False

        #start by getting current chain of notes and keeping track of b's and b-flats:
        current_chain = []
        for i in range(self._length):
            note = self._cf.get_note(i)
            if note is None: break
            current_chain.append(note)
            if note.get_scale_degree() == 7:
                if note.get_accidental() == ScaleOption.FLAT: 
                    has_b_flat = True 
                else: 
                    has_b_natural = True 
        if has_b_natural and has_b_flat:
            return False 
        #next, get the segments (consecutive notes that move in the same direction)
        #and the leap chains (consecutive notes separated by leaps)
        segments = [[current_chain[0]]]
        leap_chains = [[current_chain[0]]]
        prev_interval = None 
        for i in range(1, len(current_chain)):
            note = current_chain[i]
            prev_note = current_chain[i - 1]
            current_interval = prev_note.get_scale_degree_interval(note)
            if prev_interval is None or (prev_interval > 0 and current_interval > 0) or (prev_interval < 0 and current_interval < 0):
                segments[-1].append(note)
            else:
                segments.append([prev_note, note])
            if abs(current_interval) <= 2:
                leap_chains.append([note])
            else:
                leap_chains[-1].append(note)
            prev_interval = current_interval
        #we only need to examine segments and chains of length 3 or greater
        leap_chains = list(filter(lambda chain: len(chain) >= 3, leap_chains))
        segments = list(filter(lambda seg: len(seg) >= 3, segments))

        #check segments
        for i, seg in enumerate(segments):
            #check for dissonant intervals except in last segment unless we're checking the completed Cantus Firmus
            if i < len(segments) - 1 or len(current_chain) == self._length:
                if self._segment_outlines_illegal_interval(seg):
                    return False 
            if self._segment_has_illegal_interval_ordering(seg):
                return False

        #check leap chains
        for chain in leap_chains:
            if self._leap_chain_is_illegal(chain):
                return False 

        #check for ascending intervals 
        for i in range(1, len(current_chain) - 1):
            first_interval = current_chain[i - 1].get_scale_degree_interval(current_chain[i])
            if first_interval == 6:
                second_interval_chromatic = current_chain[i].get_chromatic_interval(current_chain[i + 1])
                if second_interval_chromatic != -1:
                    return False 
            if first_interval > 3:
                second_interval_sdg = current_chain[i].get_scale_degree_interval(current_chain[i + 1])
                if second_interval_sdg != -2 and random() > .5:
                    return False 

        #check for no sequences
        for i in range(3, len(current_chain)):
            if current_chain[i - 3].get_chromatic_interval(current_chain[i - 1]) == 0 and current_chain[i - 2].get_chromatic_interval(current_chain[i]) == 0:
                return False 
        
        return True

    def _leap_chain_is_illegal(self, chain: list[Note]) -> bool:
        for i in range(len(chain) - 2):
            for j in range(i + 2, len(chain)):
                chro_interval = chain[i].get_chromatic_interval(chain[j])
                if chro_interval not in CONSONANT_MELODIC_INTERVALS_CHROMATIC:
                    return True 
        return False

    def _segment_outlines_illegal_interval(self, seg: list[Note]) -> bool:
        chro_interval = seg[0].get_chromatic_interval(seg[-1])
        return chro_interval not in CONSONANT_MELODIC_INTERVALS_CHROMATIC

    def _segment_has_illegal_interval_ordering(self, seg: list[Note]) -> bool:
        prev_interval = seg[0].get_scale_degree_interval(seg[1])
        for i in range(1, len(seg)):
            current_interval = seg[i - 1].get_scale_degree_interval(seg[i])
            if current_interval > prev_interval:
                return True
            prev_interval = current_interval
        return False

    def _ascending_intervals_are_handled(self, solution: list[Note]) -> bool:
        for i in range(1, len(solution) - 1):
            interval = solution[i - 1].get_scale_degree_interval(solution[i])
            if interval > 2:
                filled_in = False 
                for j in range(i + 1, len(solution)):
                    if solution[i].get_scale_degree_interval(solution[j]) == -2:
                        filled_in = True
                        break
                if not filled_in: return False 
        return True

    
    def _no_intervalic_sequences(self, solution: list[Note]) -> bool:
        #check if an intervalic sequence of four or more notes repeats
        intervals = []
        for i in range(1, len(solution)):
            intervals.append(solution[i - 1].get_scale_degree_interval(solution[i]))
        for i in range(len(solution) - 6):
            seq = intervals[i: i + 3]
            for j in range(i + 3, len(solution) - 4):
                possible_match = intervals[j: j + 3]
                if seq == possible_match:
                    return False 

        #check to remove pattern leap down -> step up -> step down -> leap up
        for i in range(len(solution) - 4):
            if intervals[i] < -2 and intervals[i + 1] == 2 and intervals[i + 2] == -2 and intervals[i + 3] > 2:
                if random() < .8:
                    return False
        #check if three exact notes repeat
        for i in range(len(solution) - 5):
            for j in range(i + 3, len(solution) - 2):
                if solution[i].get_chromatic_interval(solution[j]) == 0 and solution[i + 1].get_chromatic_interval(solution[j + 1]) == 0 and solution[i + 2].get_chromatic_interval(solution[j + 2]) == 0:
                    return False 
        return True
        


    #returns valid notes, if any, at the specified interval.  "3" returns a third above.  "-5" returns a fifth below
    def _get_notes_from_interval(self, note: Note, interval: int) -> list[Note]: 
        sdg = note.get_scale_degree()
        octv = note.get_octave()
        adjustment_value = -1 if interval > 0 else 1
        new_sdg, new_octv = sdg + interval + adjustment_value, octv
        if new_sdg < 1:
            new_octv -= 1
            new_sdg += 7
        elif new_sdg > 7:
            new_octv += 1
            new_sdg -= 7
        new_note = Note(new_sdg, new_octv, 8)
        valid_notes = [new_note]
        if (self._mode == ModeOption.DORIAN or self._mode == ModeOption.LYDIAN) and new_sdg == 7:
            valid_notes.append(Note(new_sdg, new_octv, 8, accidental = ScaleOption.FLAT))
        def valid_interval(next_note: Note) -> bool:
            chro_interval = next_note.get_chromatic_with_octave() - note.get_chromatic_with_octave()
            return chro_interval in CONSONANT_MELODIC_INTERVALS_CHROMATIC
        return list(map(lambda n: (interval, n), list(filter(valid_interval, valid_notes))))
class GenerateTwoPartFifthSpecies:
    def __init__(self,
                 length: int = None,
                 mode: ModeOption = None,
                 range_option: RangeOption = None):
        self._mode = mode or ModeOption.AEOLIAN
        self._length = length or 8 + math.floor(
            random() * 5)  #todo: replace with normal distribution
        self._range = range_option if range_option is not None else RangeOption.ALTO
        self._mr = ModeResolver(self._mode, range_option=self._range)
        self._melodic_insertion_checks = [
            self._handles_adjacents,
            self._handles_interval_order,
            self._handles_nearby_augs_and_dims,
            self._handles_nearby_leading_tones,
            self._handles_ascending_minor_sixth,
            self._handles_ascending_quarter_leaps,
            self._handles_descending_quarter_leaps,
            self._handles_repetition,
            self._handles_eigths,
            self._handles_highest,
            self._handles_resolution_of_anticipation,
            self._handles_repeated_two_notes,
            self._handles_quarter_between_two_leaps,
            self._handles_upper_neighbor,
            self._handles_antipenultimate_bar,
        ]
        self._harmonic_insertion_checks = [
            self._filters_dissonance_on_downbeat, self._resolves_suspension,
            self._prepares_weak_quarter_dissonance,
            self._resolves_weak_quarter_dissonance,
            self._resolves_cambiata_tail, self._prepares_weak_half_note,
            self._resolves_dissonant_quarter_on_weak_half_note,
            self._resolves_passing_half_note, self._handles_hiddens,
            self._handles_parallels, self._handles_doubled_leading_tone
        ]
        self._melodic_rhythm_filters = [
            self._handles_runs, self._handles_consecutive_quarters,
            self._handles_penultimate_bar, self._handles_first_eighth,
            self._handles_sharp_durations, self._handles_whole_note_quota,
            self._handles_repeated_note,
            self._handles_rhythm_after_descending_quarter_leap,
            self._handles_dotted_whole_after_quarters,
            self._handles_repeated_dotted_halfs,
            self._handles_antipenultimate_rhythm,
            self._handles_half_note_chain, self._handles_missing_syncopation,
            self._handles_quarters_after_whole,
            self._handles_repetition_on_consecutive_syncopated_measures
        ]
        self._harmonic_rhythm_filters = [
            self._prepares_suspension,
            self._resolves_cambiata,
            self._handles_weak_half_note_dissonance,
        ]
        self._index_checks = [self._highest_and_lowest_placed]
        self._change_params = [
            self._check_for_highest_and_lowest,
            self._check_for_on_beat_whole_note,
            # self._check_if_new_run_is_added,
            self._check_if_eighths_are_added
        ]
        self._final_checks = [
            # self._parameters_are_correct,
            self._has_only_one_octave,
            self._no_unresolved_leading_tones
        ]
        self._params = [
            "highest_has_been_placed", "lowest_has_been_placed",
            "num_on_beat_whole_notes_placed", "eighths_have_been_placed"
        ]
        gcf = GenerateCantusFirmus(self._length, self._mode, 4)
        cf = None
        #limit ourselves to Cantus Firmuses that end with a descending step to allow for easier cadences
        while cf is None or cf.get_note(self._length -
                                        2).get_scale_degree_interval(
                                            cf.get_note(self._length -
                                                        1)) != -2:
            cf = gcf.generate_cf()
        self._cantus_object = cf
        self._cantus = cf.get_notes()

    def print_counterpoint(self):
        print("  FIFTH SPECIES:")
        for i in range(self._length):
            for j in range(4):
                cf_note = str(
                    self._cantus[i]) if j == 0 else "                   "
                cntpt_note = str(self._counterpoint_obj[(i, j)]) if (
                    i, j) in self._counterpoint_obj else ""
                if cntpt_note is None: cntpt_note = "None"
                if (i, j + 0.5) in self._counterpoint_obj:
                    cntpt_note += "  " + str(
                        self._counterpoint_obj[(i, j + 0.5)])
                show_index = "    "
                if j == 0:
                    show_index = str(i) + ":  " if i < 10 else str(i) + ": "
                print(show_index + "  " + cf_note + "  " + str(cntpt_note))

    def get_optimal(self):
        if len(self._solutions) == 0:
            return None
        optimal = self._solutions[0]
        self._map_solution_onto_counterpoint_dict(optimal)
        self.print_counterpoint()
        return [optimal, self._cantus]

    def generate_2p5s(self):
        print("MODE = ", self._mode.value["name"])
        self._solutions = []

        def attempt():
            self._num_backtracks = 0
            self._solutions_this_attempt = 0
            initialized = self._initialize()
            self._backtrack()

        attempts = 0
        while len(self._solutions) < 100 and attempts < 1:
            print("attempt", attempts)
            attempt()
            attempts += 1
        print("number of attempts:", attempts)
        print("number of solutions:", len(self._solutions))
        if len(self._solutions) > 0:
            shuffle(self._solutions)
            self._solutions.sort(key=lambda sol: self._score_solution(sol))

    def _initialize(self) -> bool:
        indices = []
        for i in range(self._length - 1):
            indices += [(i, 0), (i, 1), (i, 1.5), (i, 2), (i, 3)]
        indices += [(self._length - 1, 0)]
        self._all_indices = indices[:]
        self._remaining_indices = indices[:]
        self._remaining_indices.reverse()
        print(self._all_indices)
        #initialize counterpoint data structure, that will map indices to notes
        self._counterpoint_obj = {}
        for index in self._all_indices:
            self._counterpoint_obj[index] = None
        #also initialize counterpoint data structure as list
        self._counterpoint_lst = []
        #initialize parameters for this attempt
        self._attempt_params = {
            "lowest": None,
            "highest": None,
            "highest_must_appear_by": None,
            "lowest_must_appear_by": None,
            "highest_has_been_placed": False,
            "lowest_has_been_placed": False,
            "max_on_beat_whole_notes": None,
            "num_on_beat_whole_notes_placed": 0,
            "eighths_have_been_placed": False,
            "run_indices": set()
        }
        vocal_range = randint(8, 10)
        self._attempt_params[
            "lowest"] = self._mr.get_default_note_from_interval(
                self._mr.get_lowest(), randint(1, 13 - vocal_range))
        self._attempt_params[
            "highest"] = self._mr.get_default_note_from_interval(
                self._attempt_params["lowest"], vocal_range)
        self._attempt_params["highest_must_appear_by"] = randint(
            3, self._length - 1)
        self._attempt_params["lowest_must_appear_by"] = randint(
            3 if self._attempt_params["highest_must_appear_by"] >= 5 else 5,
            self._length - 1)
        self._attempt_params["max_on_beat_whole_notes"] = randint(1, 2)

        self._place_runs()

        self._store_params = []
        self._stored_indices = []
        self._valid_pitches = [
            self._attempt_params["lowest"], self._attempt_params["highest"]
        ]  #order is unimportant
        for i in range(2, vocal_range):
            self._valid_pitches += self._mr.get_notes_from_interval(
                self._attempt_params["lowest"], i)

        return True

    def _place_runs(self) -> None:
        runs = [randint(5, 11)]
        if self._length > 8: runs.append(4)
        shuffle(runs)
        start_beats = []
        for run in runs:
            pos = randint(3, (self._length - 2) * 4 - run)
            while pos % 4 == 0:
                pos = randint(3, (self._length - 2) * 4 - run)
            start_beats.append(pos)
        if len(runs) == 2 and start_beats[0] + runs[0] + 12 >= start_beats[1]:
            start_beats.pop()
            runs.pop()
        for i in range(len(runs)):
            for j in range(runs[i]):
                total_beats = start_beats[i] + j
                index = (total_beats // 4, total_beats % 4)
                self._attempt_params["run_indices"].add(index)

    def _backtrack(self) -> None:
        if (self._num_backtracks >
                100000) or (self._solutions_this_attempt == 0
                            and self._num_backtracks > 10000):
            return
        self._num_backtracks += 1
        if self._num_backtracks % 10000 == 0:
            print("backtrack number:", self._num_backtracks)
        if len(self._remaining_indices) == 0:
            if self._passes_final_checks():
                if self._solutions_this_attempt == 0:
                    print("FOUND SOLUTION!")
                self._solutions.append(self._counterpoint_lst[:])
                self._solutions_this_attempt += 1
            return
        (bar, beat) = self._remaining_indices.pop()
        if self._passes_index_checks((bar, beat)):
            candidates = list(
                filter(lambda n: self._passes_insertion_checks(n, (bar, beat)),
                       self._valid_pitches))
            shuffle(candidates)
            if bar == 0 and beat == 0:
                candidates.append(Note(1, 0, 4, accidental=ScaleOption.REST))
            # print("candidates for index", bar, beat, ": ", len(candidates))
            notes_to_insert = []
            for candidate in candidates:
                durations = self._get_valid_durations(candidate, (bar, beat))
                for dur in durations:
                    notes_to_insert.append(
                        Note(candidate.get_scale_degree(),
                             candidate.get_octave(),
                             dur,
                             accidental=candidate.get_accidental()))
            shuffle(notes_to_insert)
            for note_to_insert in notes_to_insert:
                self._insert_note(note_to_insert, (bar, beat))
                self._backtrack()
                self._remove_note(note_to_insert, (bar, beat))
        self._remaining_indices.append((bar, beat))

    def _passes_index_checks(self, index: tuple) -> bool:
        for check in self._index_checks:
            if not check(index): return False
        return True

    def _passes_insertion_checks(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if bar == 0 and (beat == 0 or
                         (beat == 2
                          and self._counterpoint_lst[0].get_accidental()
                          == ScaleOption.REST)):
            return self._check_starting_pitch(note)
        if bar == self._length - 1:
            if not self._check_last_pitch(note): return False
        for check in self._melodic_insertion_checks:
            if not check(note, (bar, beat)):
                # print("failed insertion check:", str(note), index, "on function", check.__name__)
                return False
        # print("passed insertion checks!", str(note), index)
        for check in self._harmonic_insertion_checks:
            if not check(note, (bar, beat)):
                # print("failed insertion check:", str(note), index, "on function", check.__name__)
                return False
        return True

    def _get_valid_durations(self, note: Note, index: tuple) -> set:
        (bar, beat) = index
        if bar == self._length - 1: return {16}
        if note.get_accidental() == ScaleOption.REST: return {4}
        if bar == 0 and beat == 0: return self._get_first_beat_options(note)
        durs = self._get_durations_from_beat(index)
        prev_length = len(durs)
        for check in self._melodic_rhythm_filters:
            durs = check(note, index, durs)
            if len(durs) == 0: break
        for check in self._harmonic_rhythm_filters:
            durs = check(note, index, durs)
            if len(durs) == 0: break
        return durs

    def _insert_note(self, note: Note, index: tuple) -> set:
        self._counterpoint_lst.append(note)
        self._counterpoint_obj[index] = note
        self._store_params.append({})
        for param in self._params:
            self._store_params[-1][param] = self._attempt_params[param]
        self._bury_indices(note, index)
        for check in self._change_params:
            check(note, index)

    def _remove_note(self, note: Note, index: tuple) -> set:
        self._counterpoint_lst.pop()
        self._counterpoint_obj[index] = None
        for param in self._params:
            self._attempt_params[param] = self._store_params[-1][param]
        self._store_params.pop()
        self._unbury_indices(note, index)

    def _passes_final_checks(self) -> bool:
        for check in self._final_checks:
            if not check():
                # print("failed final check:", check.__name__)
                return False
        return True

    ######################################
    ### melodic insertion checks #########

    def _check_starting_pitch(self, note: Note) -> bool:
        if note.get_accidental() == ScaleOption.REST:
            return True
        if self._cantus[0].get_scale_degree_interval(note) not in [
                -8, 1, 5, 8
        ]:
            return False
        return note.get_accidental() == ScaleOption.NATURAL

    def _check_last_pitch(self, note: Note) -> bool:
        if self._mr.get_final() != note.get_scale_degree(
        ) or note.get_accidental() != ScaleOption.NATURAL:
            return False
        if self._counterpoint_lst[-1].get_scale_degree_interval(note) == 2:
            return self._mr.is_unison(self._mr.get_leading_tone_of_note(note),
                                      self._counterpoint_lst[-1])
        if self._counterpoint_lst[-1] != -2: return False
        return self._mr.is_unison(self._counterpoint_lst[-1],
                                  self._mr.get_leading_tone_of_note(note))

    def _handles_adjacents(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        (sdg_interval,
         chro_interval) = self._mr.get_intervals(self._counterpoint_lst[-1],
                                                 note)
        if sdg_interval not in LegalIntervalsFifthSpecies[
                "adjacent_melodic_scalar"]:
            return False
        if chro_interval not in LegalIntervalsFifthSpecies[
                "adjacent_melodic_chromatic"]:
            return False
        if (sdg_interval, chro_interval
            ) in LegalIntervalsFifthSpecies["forbidden_combinations"]:
            return False
        return True

    def _handles_interval_order(self, note: Note, index: tuple) -> bool:
        potential_interval = self._counterpoint_lst[
            -1].get_scale_degree_interval(note)
        if potential_interval >= 3:
            for i in range(len(self._counterpoint_lst) - 2, -1, -1):
                interval = self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])
                if interval < 0: return True
                if interval > 2: return False
        if potential_interval == 2:
            segment_has_leap = False
            for i in range(len(self._counterpoint_lst) - 2, -1, -1):
                interval = self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])
                if interval < 0: return True
                if segment_has_leap: return False
                segment_has_leap = interval > 2
        if potential_interval == -2:
            segment_has_leap = False
            for i in range(len(self._counterpoint_lst) - 2, -1, -1):
                interval = self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])
                if interval > 0: return True
                if segment_has_leap or interval == -8: return False
                segment_has_leap = interval < -2
        if potential_interval <= -3:
            for i in range(len(self._counterpoint_lst) - 2, -1, -1):
                interval = self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])
                if interval > 0: return True
                if interval < -2: return False
        return True

    def _handles_nearby_augs_and_dims(self, note: Note, index: tuple) -> bool:
        if len(self._counterpoint_lst) < 2: return True
        if self._mr.is_cross_relation(
                note, self._counterpoint_lst[-2]
        ) and self._counterpoint_lst[-1].get_duration() <= 2:
            return False
        if self._counterpoint_lst[-2].get_duration(
        ) != 2 and self._counterpoint_lst[-1].get_duration() != 2:
            return True
        (sdg_interval,
         chro_interval) = self._mr.get_intervals(self._counterpoint_lst[-2],
                                                 note)
        return (abs(sdg_interval) != 2
                or abs(chro_interval) != 3) and (abs(sdg_interval) != 3
                                                 or abs(chro_interval) != 2)

    def _handles_nearby_leading_tones(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat == 2 and (
                bar - 1,
                2) in self._counterpoint_obj and self._counterpoint_obj[
                    (bar - 1, 2)].get_duration() > 4:
            if self._mr.is_sharp(self._counterpoint_obj[(
                    bar - 1, 2)]) and self._counterpoint_obj[
                        (bar - 1, 2)].get_chromatic_interval(note) != 1:
                return False
        if beat == 0 and bar != 0:
            for i, num in enumerate([0, 1, 1.5, 2, 3]):
                if (bar - 1,
                        num) in self._counterpoint_obj and self._mr.is_sharp(
                            self._counterpoint_obj[(bar - 1, num)]):
                    resolved = False
                    for j in range(i + 1, 5):
                        next_index = (bar - 1, [0, 1, 1.5, 2, 3][j])
                        if next_index in self._counterpoint_obj and self._counterpoint_obj[
                            (bar - 1, num)].get_chromatic_interval(
                                self._counterpoint_obj[next_index]) == 1:
                            resolved = True
                    if not resolved and self._counterpoint_obj[
                        (bar - 1, num)].get_chromatic_interval(note) != 1:
                        return False
        return True

    def _handles_ascending_minor_sixth(self, note: Note, index: tuple) -> bool:
        if len(self._counterpoint_lst) < 2: return True
        if self._counterpoint_lst[-2].get_chromatic_interval(
                self._counterpoint_lst[-1]) == 8:
            return self._counterpoint_lst[-1].get_chromatic_interval(
                note) == -1
        return True

    def _handles_ascending_quarter_leaps(self, note: Note,
                                         index: tuple) -> bool:
        (bar, beat) = index
        if self._counterpoint_lst[-1].get_scale_degree_interval(note) > 2:
            if beat % 2 == 1: return False
            if len(self._counterpoint_lst
                   ) >= 2 and self._counterpoint_lst[-1].get_duration() == 2:
                if self._counterpoint_lst[-2].get_scale_degree_interval(
                        self._counterpoint_lst[-1]) > 0:
                    return False
        return True

    def _handles_descending_quarter_leaps(self, note: Note,
                                          index: tuple) -> bool:
        (bar, beat) = index
        if len(self._counterpoint_lst) < 2: return True
        if self._counterpoint_lst[-2].get_scale_degree_interval(
                self._counterpoint_lst[-1]
        ) < -2 and self._counterpoint_lst[-1].get_duration() == 2:
            if self._counterpoint_lst[-1].get_scale_degree_interval(note) == 2:
                return True
            return self._counterpoint_lst[-2].get_scale_degree_interval(
                note) in [-2, 1, 2]
        return True

    def _handles_repetition(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if self._mr.is_unison(self._counterpoint_lst[-1], note) and (
                beat != 2 or self._counterpoint_lst[-1].get_duration() != 2):
            return False
        return True

    def _handles_eigths(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat == 1.5 and abs(self._counterpoint_lst[-1].
                               get_scale_degree_interval(note)) != 2:
            return False
        if beat != 2: return True
        if self._counterpoint_lst[-1].get_duration() != 1: return True
        first_interval = self._counterpoint_lst[-3].get_scale_degree_interval(
            self._counterpoint_lst[-2])
        second_interval = self._counterpoint_lst[-2].get_scale_degree_interval(
            self._counterpoint_lst[-1])
        third_interval = self._counterpoint_lst[-1].get_scale_degree_interval(
            note)
        if abs(third_interval) != 2 or (second_interval == 2 and third_interval
                                        == -2) or (first_interval == 2
                                                   and second_interval == -2):
            return False
        return True

    def _handles_highest(self, note: Note, index: tuple) -> bool:
        if self._attempt_params[
                "highest_has_been_placed"] and self._mr.is_unison(
                    self._attempt_params["highest"], note):
            return False
        return True

    def _handles_resolution_of_anticipation(self, note: Note,
                                            index: tuple) -> bool:
        if len(self._counterpoint_lst) < 2 or not self._mr.is_unison(
                self._counterpoint_lst[-2], self._counterpoint_lst[-1]):
            return True
        return self._counterpoint_lst[-1].get_scale_degree_interval(note) == -2

    def _handles_repeated_two_notes(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if len(self._counterpoint_lst) < 3: return True
        if not self._mr.is_unison(
                self._counterpoint_lst[-3],
                self._counterpoint_lst[-1]) or not self._mr.is_unison(
                    self._counterpoint_lst[-2], note):
            return True
        if self._counterpoint_lst[-1].get_scale_degree_interval(note) != 2:
            return False
        if self._counterpoint_lst[-2].get_duration() != 8 or beat != 0:
            return False
        return True

    def _handles_quarter_between_two_leaps(self, note: Note,
                                           index: tuple) -> bool:
        if self._counterpoint_lst[-1].get_duration() != 2 or len(
                self._counterpoint_lst) < 2:
            return True
        first_interval, second_interval = self._counterpoint_lst[
            -2].get_scale_degree_interval(
                self._counterpoint_lst[-1]
            ), self._counterpoint_lst[-1].get_scale_degree_interval(note)
        if abs(first_interval) == 2 or abs(second_interval) == 2:
            return True
        if first_interval > 0 and second_interval < 0: return False
        if first_interval == -8 and second_interval == 8: return False
        return True

    def _handles_upper_neighbor(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if (beat % 2 == 0 and self._counterpoint_lst[-1].get_duration() == 2
                and self._counterpoint_lst[-1].get_scale_degree_interval(note)
                == -2 and len(self._counterpoint_lst) >= 2
                and self._counterpoint_lst[-2].get_scale_degree_interval(
                    self._counterpoint_lst[-1]) == 2
                and self._counterpoint_lst[-2].get_duration() != 2):
            return False
        return True

    def _handles_antipenultimate_bar(self, note: Note, index: tuple) -> bool:
        if index == (self._length - 3, 2):
            if note.get_accidental(
            ) != ScaleOption.NATURAL or note.get_scale_degree(
            ) != self._mr.get_final():
                return False
        return True

    ######################################
    ###### harmonic insertion checks ######

    def _filters_dissonance_on_downbeat(self, note: Note,
                                        index: tuple) -> bool:
        (bar, beat) = index
        if beat != 0: return True
        cf_note = self._cantus[bar]
        return self._is_consonant(cf_note, note)

    def _resolves_suspension(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat not in [1, 2] or (bar, 0) in self._counterpoint_obj:
            return True
        susp_index = (bar - 1,
                      2) if (bar - 1,
                             2) in self._counterpoint_obj else (bar - 1, 0)
        cf_note, susp = self._cantus[bar], self._counterpoint_obj[susp_index]
        if cf_note.get_scale_degree_interval(
                susp) in LegalIntervalsFifthSpecies["resolvable_dissonance"]:
            return susp.get_scale_degree_interval(note) == -2
        return True

    def _prepares_weak_quarter_dissonance(self, note: Note,
                                          index: tuple) -> bool:
        (bar, beat) = index
        if beat % 2 != 1 or self._is_consonant(self._cantus[bar], note):
            return True
        if not self._is_consonant(self._cantus[bar],
                                  self._counterpoint_lst[-1]):
            return False
        return abs(
            self._counterpoint_lst[-1].get_scale_degree_interval(note)) == 2

    def _resolves_weak_quarter_dissonance(self, note: Note,
                                          index: tuple) -> bool:
        (bar, beat) = index
        if beat % 2 != 0 or self._counterpoint_lst[-1].get_duration() != 2:
            return True
        if self._is_consonant(self._cantus[bar if beat > 0 else bar - 1],
                              self._counterpoint_lst[-1]):
            return True
        first_interval = self._counterpoint_lst[-2].get_scale_degree_interval(
            self._counterpoint_lst[-1])
        second_interval = self._counterpoint_lst[-1].get_scale_degree_interval(
            note)
        if second_interval not in [-3, -2, 1]: return False
        if first_interval == 2 and second_interval == -3: return False
        return True

    def _resolves_cambiata_tail(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat == 1.5: return True
        first_index, second_index = (bar - 1, 1), (bar - 1, 2)
        if beat in [1, 2]:
            first_index, second_index = (bar - 1, 3), (bar, 0)
        if beat == 3:
            first_index, second_index = (bar, 1), (bar, 2)
        if first_index not in self._counterpoint_obj or second_index not in self._counterpoint_obj:
            return True
        cf_note = self._cantus[bar if beat == 3 else bar - 1]
        if not self._is_consonant(
                cf_note, self._counterpoint_obj[first_index]
        ) and self._counterpoint_obj[first_index].get_scale_degree_interval(
                self._counterpoint_obj[second_index]) == -3:
            return self._counterpoint_lst[-1].get_scale_degree_interval(
                note) == 2
        return True

    def _prepares_weak_half_note(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat != 2: return True
        cf_note = self._cantus[bar]
        if self._is_consonant(cf_note, note): return True
        if (bar, 0) not in self._counterpoint_obj or self._counterpoint_obj[
            (bar, 0)].get_duration() != 4:
            return False
        return abs(
            self._counterpoint_obj[(bar,
                                    0)].get_scale_degree_interval(note)) == 2

    def _resolves_dissonant_quarter_on_weak_half_note(self, note: Note,
                                                      index: tuple) -> bool:
        (bar, beat) = index
        if beat != 3 or (bar, 2) not in self._counterpoint_obj: return True
        if self._is_consonant(self._cantus[bar],
                              self._counterpoint_obj[(bar, 2)]):
            return True
        return self._counterpoint_obj[(
            bar, 2)].get_scale_degree_interval(note) == -2

    def _resolves_passing_half_note(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat != 0 or (
                bar - 1,
                2) not in self._counterpoint_obj or self._counterpoint_obj[
                    (bar - 1, 2)].get_duration() != 4:
            return True
        if self._is_consonant(self._counterpoint_obj[(bar - 1, 2)],
                              self._cantus[bar - 1]):
            return True
        return self._counterpoint_lst[-2].get_scale_degree_interval(
            self._counterpoint_lst[-1]
        ) == self._counterpoint_lst[-1].get_scale_degree_interval(note)

    def _handles_hiddens(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat != 0 or self._cantus[bar].get_chromatic_interval(note) not in [
                -19, -12, -7, 0, 7, 12, 19
        ]:
            return True
        upper_interval = self._counterpoint_lst[-1].get_scale_degree_interval(
            note)
        lower_interval = self._cantus[bar - 1].get_scale_degree_interval(
            self._cantus[bar])
        if (upper_interval > 0
                and lower_interval > 0) or (upper_interval < 0
                                            and lower_interval < 0):
            return False
        return True

    def _handles_parallels(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat == 2 and self._counterpoint_lst[-1].get_duration(
        ) >= 8 and self._cantus[bar].get_chromatic_interval(note) in [
                -19, -12, 0, 12, 19
        ]:
            return self._cantus[bar].get_chromatic_interval(
                note) != self._cantus[bar - 1].get_chromatic_interval(
                    self._counterpoint_lst[-1])
        if beat != 0 or self._cantus[bar].get_chromatic_interval(note) not in [
                -19, -12, 0, 12, 19
        ]:
            return True
        if (bar - 1, 2) in self._counterpoint_obj and self._cantus[
                bar - 1].get_chromatic_interval(self._counterpoint_obj[(
                    bar - 1,
                    2)]) == self._cantus[bar].get_chromatic_interval(note):
            return False
        index_to_check = (bar - 1, 0)
        if index_to_check not in self._counterpoint_obj or self._counterpoint_obj[
                index_to_check].get_duration() == 2:
            return True
        if self._cantus[bar - 1].get_chromatic_interval(
                self._counterpoint_obj[index_to_check]
        ) == self._cantus[bar].get_chromatic_interval(note):
            return False
        return True

    def _handles_doubled_leading_tone(self, note: Note, index: tuple) -> bool:
        (bar, beat) = index
        if beat != 0 or self._cantus[bar].get_chromatic_interval(note) not in [
                -12, 0, 12
        ]:
            return True
        if (note.get_scale_degree() + 1) % 7 == self._mr.get_final():
            return False
        return True

    ######################################
    ###### melodic rhythms filters #######

    def _handles_runs(self, note: Note, index: tuple, durs: set) -> set:
        (bar, beat) = index
        if index in self._attempt_params["run_indices"]:
            return {2} if 2 in durs else set()
        if (bar, beat + 1) in self._attempt_params["run_indices"]:
            for d in [4, 6, 8, 12]:
                durs.discard(d)
        two_beats_next = (bar, beat + 2) if beat == 0 else (bar + 1, 0)
        if two_beats_next in self._attempt_params["run_indices"]:
            for d in [2, 6, 8, 12]:
                durs.discard(d)
        three_beats_next = (bar, beat + 3) if beat == 0 else (bar + 1, 1)
        if three_beats_next in self._attempt_params["run_indices"]:
            for d in [2, 8, 12]:
                durs.discard(d)
        if (bar + 1, 2) in self._attempt_params["run_indices"]:
            durs.discard(12)
        return durs

    def _get_durations_from_beat(self, index: tuple) -> set:
        (bar, beat) = index
        if beat == 1.5: return {1}
        if beat == 3: return {2}
        if beat == 1: return {1, 2}
        if beat == 2: return {2, 4, 6, 8}
        if beat == 0: return {2, 4, 6, 8, 12} if bar == 0 else {2, 4, 6, 8}

    def _handles_consecutive_quarters(self, note: Note, index: tuple,
                                      durs: set) -> set:
        (bar, beat) = index
        if self._counterpoint_lst[-1].get_duration() != 2: return durs
        if self._counterpoint_lst[-1].get_scale_degree_interval(
                note) > 0 and beat == 2:
            durs.discard(4)
        if beat == 2 and self._counterpoint_lst[-2].get_duration(
        ) == 2 and self._counterpoint_lst[-3].get_duration() != 2:
            durs.discard(4)
        for i in range(len(self._counterpoint_lst) - 2, -1, -1):
            if self._counterpoint_lst[i].get_duration() != 2:
                return durs
            if abs(self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])) > 2:
                durs.discard(2)
                return durs

    def _handles_penultimate_bar(self, note: Note, index: tuple,
                                 durs: set) -> set:
        (bar, beat) = index
        if bar != self._length - 2: return durs
        if beat == 2:
            durs.discard(8)
            durs.discard(6)
            durs.discard(2)
        if beat == 0:
            durs.discard(12)
        return durs

    def _handles_first_eighth(self, note: Note, index: tuple,
                              durs: set) -> set:
        (bar, beat) = index
        if (beat == 1 and
                abs(self._counterpoint_lst[-1].get_scale_degree_interval(note))
                != 2) or self._attempt_params["eighths_have_been_placed"]:
            durs.discard(1)
        if beat == 2 and self._counterpoint_lst[-1].get_duration(
        ) == 1 and self._counterpoint_lst[-3].get_duration() == 2:
            durs.discard(4)
            durs.discard(8)
            durs.discard(6)
        return durs

    def _handles_sharp_durations(self, note: Note, index: tuple,
                                 durs: set) -> set:
        if self._mr.is_sharp(note): durs.discard(12)
        return durs

    def _handles_whole_note_quota(self, note: Note, index: tuple,
                                  durs: set) -> set:
        (bar, beat) = index
        if self._attempt_params[
                "num_on_beat_whole_notes_placed"] == self._attempt_params[
                    "max_on_beat_whole_notes"]:
            if beat == 0:
                durs.discard(8)
                durs.discard(12)
        return durs

    def _handles_repeated_note(self, note: Note, index: tuple,
                               durs: set) -> set:
        if self._mr.is_unison(self._counterpoint_lst[-1], note):
            durs.discard(4)
            durs.discard(2)
        return durs

    def _handles_rhythm_after_descending_quarter_leap(self, note: Note,
                                                      index: tuple,
                                                      durs: set) -> set:
        (bar, beat) = index
        if self._counterpoint_lst[-1].get_duration(
        ) == 2 and self._counterpoint_lst[-1].get_scale_degree_interval(
                note) < -2:
            durs.discard(8)
            durs.discard(12)
            durs.discard(6)
        return durs

    def _handles_dotted_whole_after_quarters(self, note: Note, index: tuple,
                                             durs: set) -> set:
        if self._counterpoint_lst[-1].get_duration() == 2: durs.discard(12)
        return durs

    def _handles_repeated_dotted_halfs(self, note: Note, index: tuple,
                                       durs: set) -> set:
        (bar, beat) = index
        if beat != 0: return durs
        if (bar - 1, 0) in self._counterpoint_obj and self._counterpoint_obj[(
                bar - 1, 0)].get_duration() == 6:
            durs.discard(6)
        if bar % 2 == 0 and (
                bar - 2,
                0) in self._counterpoint_obj and self._counterpoint_obj[(
                    bar - 2, 0)].get_duration() == 6:
            durs.discard(6)
        return durs

    def _handles_antipenultimate_rhythm(self, note: Note, index: tuple,
                                        durs: set) -> set:
        if index == (self._length - 3, 2):
            durs.discard(4)
            durs.discard(2)
        if index == (self._length - 3, 0):
            durs.discard(8)
            durs.discard(6)
        return durs

    def _handles_half_note_chain(self, note: Note, index: tuple,
                                 durs: set) -> set:
        (bar, beat) = index
        if beat == 2 and len(self._counterpoint_lst) >= 3:
            if self._counterpoint_lst[-3].get_duration(
            ) == 4 and self._counterpoint_lst[-2].get_duration(
            ) == 4 and self._counterpoint_lst[-1].get_duration() == 4:
                durs.discard(4)
        return durs

    def _handles_missing_syncopation(self, note: Note, index: tuple,
                                     durs: set) -> set:
        (bar, beat) = index
        if beat != 0 or (bar - 1, 0) not in self._counterpoint_obj or (
                bar - 2, 0) not in self._counterpoint_obj or (
                    bar - 3, 0) not in self._counterpoint_obj:
            return durs
        if self._counterpoint_obj[
            (bar - 3, 0)].get_duration() >= 4 and self._counterpoint_obj[
                (bar - 2, 0)].get_duration() >= 4 and self._counterpoint_obj[
                    (bar - 1, 0)].get_duration() >= 4:
            durs.discard(4)
            durs.discard(6)
            durs.discard(8)
        return durs

    def _handles_quarters_after_whole(self, note: Note, index: tuple,
                                      durs: set) -> set:
        (bar, beat) = index
        if beat == 0 and self._counterpoint_lst[-1].get_duration() == 8:
            durs.discard(2)
        return durs

    def _handles_repetition_on_consecutive_syncopated_measures(
            self, note: Note, index: tuple, durs: set) -> set:
        (bar, beat) = index
        if beat == 2 and (bar, 0) not in self._counterpoint_obj and (
                bar - 1, 2) in self._counterpoint_obj and self._mr.is_unison(
                    self._counterpoint_obj[(bar - 1, 2)], note):
            durs.discard(6)
            durs.discard(8)
        return durs

    ##########################################
    ###### harmonic rhythm filters ###########

    def _get_first_beat_options(self, note: Note) -> set:
        durs = {4, 6, 8, 12}
        if not self._is_consonant(
                self._cantus[1],
                note) and self._cantus[1].get_scale_degree_interval(
                    note
                ) not in LegalIntervalsFifthSpecies["resolvable_dissonance"]:
            durs.discard(12)
        return durs

    def _prepares_suspension(self, note: Note, index: tuple, durs: set) -> set:
        (bar, beat) = index
        if bar == self._length - 1 or self._is_consonant(
                self._cantus[bar + 1], note):
            return durs
        if self._cantus[bar + 1].get_scale_degree_interval(
                note) in LegalIntervalsFifthSpecies["resolvable_dissonance"]:
            return durs
        if beat == 0:
            durs.discard(12)
        if beat == 2:
            durs.discard(8)
            durs.discard(6)
        return durs

    def _resolves_cambiata(self, note: Note, index: tuple, durs: set) -> set:
        (bar, beat) = index
        if beat % 2 != 0: return durs
        index_to_check = (bar - 1, 3) if beat == 0 else (bar, 1)
        if index_to_check not in self._counterpoint_obj: return durs
        if self._is_consonant(self._cantus[bar - 1 if beat == 0 else bar],
                              self._counterpoint_obj[index_to_check]):
            return durs
        if self._counterpoint_obj[index_to_check].get_scale_degree_interval(
                note) != -3:
            return durs
        durs.discard(12)
        durs.discard(8)
        durs.discard(6)
        return durs

    def _handles_weak_half_note_dissonance(self, note: Note, index: tuple,
                                           durs: set) -> set:
        (bar, beat) = index
        if beat != 2 or self._is_consonant(self._cantus[bar], note):
            return durs
        durs.discard(6)
        durs.discard(8)
        if self._counterpoint_lst[-1].get_scale_degree_interval(note) == 2:
            durs.discard(2)
        return durs

    ##########################################
    ########### index checks #################

    def _highest_and_lowest_placed(self, index: tuple) -> bool:
        (bar, beat) = index
        if bar >= self._attempt_params[
                "highest_must_appear_by"] and not self._attempt_params[
                    "highest_has_been_placed"]:
            return False
        if bar >= self._attempt_params[
                "lowest_must_appear_by"] and not self._attempt_params[
                    "lowest_has_been_placed"]:
            return False
        return True

    ##########################################
    ########### insert functions #############

    def _bury_indices(self, note: Note, index: tuple) -> None:
        (bar, beat) = index
        self._stored_indices.append([])
        for i in range(1, note.get_duration()):
            new_beat, new_bar = beat + (i / 2), bar
            while new_beat >= 4:
                new_beat -= 4
                new_bar += 1
            if (new_bar, new_beat) in self._counterpoint_obj:
                self._stored_indices[-1].append((new_bar, new_beat))
                del self._counterpoint_obj[(new_bar, new_beat)]
                self._all_indices.remove((new_bar, new_beat))
                self._remaining_indices.remove((new_bar, new_beat))

    def _unbury_indices(self, note: Note, index: tuple) -> None:
        i = len(self._counterpoint_lst) + 1
        while len(self._stored_indices[-1]) > 0:
            next_index = self._stored_indices[-1].pop()
            self._all_indices.insert(i, next_index)
            self._remaining_indices.append(next_index)
            self._counterpoint_obj[next_index] = None
        self._stored_indices.pop()

    def _check_for_highest_and_lowest(self, note: Note, index: tuple) -> None:
        if self._mr.is_unison(note, self._attempt_params["highest"]):
            self._attempt_params["highest_has_been_placed"] = True
        if self._mr.is_unison(note, self._attempt_params["lowest"]):
            self._attempt_params["lowest_has_been_placed"] = True

    def _check_for_on_beat_whole_note(self, note: Note, index: tuple) -> None:
        (bar, beat) = index
        if beat == 0 and note.get_duration() >= 8:
            self._attempt_params["num_on_beat_whole_notes_placed"] += 1

    def _check_if_new_run_is_added(self, note: Note, index: tuple) -> None:
        run_length = 0
        for i in range(len(self._counterpoint_lst) - 1, -1, -1):
            dur = self._counterpoint_lst[i].get_duration()
            if dur > 2:
                break
            run_length += dur / 2
        # if run_length > 7:
        #     print("run length:", run_length)
        if run_length == 4:
            self._attempt_params["num_runs_placed"] += 1
        if run_length == self._attempt_params["min_length_of_max_quarter_run"]:
            self._attempt_params["max_quarter_run_has_been_placed"] = True

    def _check_if_eighths_are_added(self, note: Note, index: tuple) -> None:
        (bar, beat) = index
        if beat == 1.5: self._attempt_params["eighths_have_been_placed"] = True

    ##########################################
    ########### final checks #################

    def _parameters_are_correct(self) -> bool:
        # print("num runs placed:", self._attempt_params["num_runs_placed"])
        # print("max run has been placed?", self._attempt_params["max_quarter_run_has_been_placed"])
        return self._attempt_params["num_runs_placed"] >= self._attempt_params[
            "min_runs_of_length_4_or_more"] and self._attempt_params[
                "max_quarter_run_has_been_placed"]

    def _has_only_one_octave(self) -> bool:
        num_octaves = 0
        for i in range(
                0 if
                self._counterpoint_lst[0].get_accidental() != ScaleOption.REST
                else 1,
                len(self._counterpoint_lst) - 1):
            if abs(self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])) == 8:
                num_octaves += 1
                if num_octaves > 1:
                    return False
        return True

    def _no_unresolved_leading_tones(self) -> bool:
        for i in range(1, self._length - 2):
            if (i, 0) not in self._counterpoint_obj:
                notes_to_check = []
                for index in [(i - 1, 0), (i - 1, 1), (i - 1, 2), (i, 2)]:
                    if index in self._counterpoint_obj:
                        notes_to_check.append(self._counterpoint_obj[index])
                for j, note in enumerate(notes_to_check):
                    if self._mr.is_sharp(note):
                        resolved = False
                        for k in range(j + 1, len(notes_to_check)):
                            if note.get_chromatic_interval(
                                    notes_to_check[k]) == 1:
                                resolved = True
                        if not resolved: return False
        return True

    ##########################################
    ########### scoring ######################

    def _score_solution(self, solution: list[Note]) -> int:
        score = 0
        self._map_solution_onto_counterpoint_dict(solution)
        num_ties = 0
        num_tied_dotted_halfs = 0
        num_tied_wholes = 0
        ties = [False] * (self._length - 2)
        for i in range(1, self._length - 1):
            if (i, 0) not in self._counterpoint_obj:
                ties[i - 1] = True
                num_ties += 1
                if (i - 1, 2) in self._counterpoint_obj:
                    if self._counterpoint_obj[(i - 1, 2)].get_duration() == 6:
                        num_tied_dotted_halfs += 1
                    else:
                        num_tied_wholes += 1
        ideal_ties = 3 if self._length < 12 else 4
        score += abs(ideal_ties - num_ties) * 10
        score += abs(num_tied_wholes - num_tied_dotted_halfs) * 5
        has_isolated_tie = False
        for i in range(1, len(ties) - 1):
            if ties[i - 1] == False and ties[i] == True and ties[i +
                                                                 1] == False:
                has_isolated_tie = True
        if has_isolated_tie: score -= 12
        num_quarter_runs_starting_on_beat = 0
        num_quarter_runs_starting_on_beat_of_length_two = 0
        num_other_two_note_quarter_runs = 0
        for i, index in enumerate(self._all_indices):
            (bar, beat) = index
            if beat == 0 and self._counterpoint_lst[i].get_duration(
            ) == 2 and self._counterpoint_lst[i - 1].get_duration() != 2:
                num_quarter_runs_starting_on_beat += 1
                if self._counterpoint_lst[i + 2].get_duration() != 2:
                    num_quarter_runs_starting_on_beat_of_length_two += 1
            if beat == 2 and self._counterpoint_lst[i].get_duration(
            ) == 2 and self._counterpoint_lst[i - 1].get_duration() != 2:
                if self._counterpoint_lst[i + 2].get_duration() != 2:
                    num_other_two_note_quarter_runs += 1
        score += num_quarter_runs_starting_on_beat * 60 + num_quarter_runs_starting_on_beat_of_length_two * 60 + num_other_two_note_quarter_runs * 45
        num_fifths, num_octaves = 0, 0
        for i in range(1, self._length - 2):
            if (i, 0) in self._counterpoint_obj:
                intvl = self._cantus[i].get_chromatic_interval(
                    self._counterpoint_obj[(i, 0)])
                if intvl in [-19, -7, 7, 19]: num_fifths += 1
                elif intvl in [-12, 0, 12]: num_octaves += 1
        score += num_fifths * 30 + num_octaves * 10
        num_steps = 0
        for i in range(len(self._counterpoint_lst) - 1):
            if abs(self._counterpoint_lst[i].get_scale_degree_interval(
                    self._counterpoint_lst[i + 1])) == 2:
                num_steps += 1
        score += math.floor(
            150 * abs(.712 - (num_steps / (len(self._counterpoint_lst) - 1))))
        return score

    def _map_solution_onto_counterpoint_dict(self,
                                             solution: list[Note]) -> None:
        self._counterpoint_obj = {}
        self._counterpoint_lst = []
        self._all_indices = []
        bar, beat = 0, 0
        self._all_indices = []
        for note in solution:
            self._counterpoint_obj[(bar, beat)] = note
            self._counterpoint_lst.append(note)
            self._all_indices.append((bar, beat))
            beat += note.get_duration() / 2
            while beat >= 4:
                beat -= 4
                bar += 1

    def _is_consonant(self, note1: Note, note2: Note) -> bool:
        (sdg_interval, chro_interval) = self._mr.get_intervals(note1, note2)
        if sdg_interval not in LegalIntervalsFifthSpecies["harmonic_scalar"]:
            return False
        if chro_interval not in LegalIntervalsFifthSpecies[
                "harmonic_chromatic"]:
            return False
        if (sdg_interval, chro_interval
            ) in LegalIntervalsFifthSpecies["forbidden_combinations"]:
            return False
        return True