ASSIGNMENT_1

# Define the statements
# EDIT THE FILE WITH YOUR SOLUTION
import sys
from os.path import exists
import re

file_name = input('Which text file do you want to use for the puzzle? '
                  ).removesuffix('\n')
if not exists(file_name):
    print('Incorrect input, giving up.')
    sys.exit()

name_set = set()
all_names = []

combined_text = ''
speaker_said_part_list = []
statement_sentence_list = []

speaker_names = []

with open(file_name) as file:
    for line1 in file:
        if line1.isspace():
            continue
        line1 = line1.strip()
        combined_text += line1 + ' '


def find_single_sentences(combined_text):
    sentence_group = []
    combined_text_list = combined_text.split()

    cur_index = 0
    while cur_index < len(combined_text_list):
        cur_sentence = ''
        if combined_text_list[cur_index][0].isupper() or (
                combined_text_list[cur_index].startswith('"') and not combined_text_list[
            cur_index - 1].endswith(':')):

            while cur_index < len(combined_text_list):
                cur_sentence += combined_text_list[cur_index] + ' '
                if (combined_text_list[cur_index].endswith(('."', '!"', '?"'))) or combined_text_list[
                    cur_index].endswith(('.', '!', '?')):
                    break
                cur_index += 1
            sentence_group.append(cur_sentence.strip())
        cur_index += 1
    return sentence_group


def partition(sentence_group):
    for sentence in sentence_group:
        statement_part = ''
        speaker_said_part = ''

        if '"' in sentence:
            if sentence.find(' "') != -1 and sentence.find(',"') != -1:
                if 'Sir' in sentence[:sentence.find(' "')]:
                    speaker_said_part = sentence[:sentence.find(' "')]
                    statement_part = sentence[sentence.find(' "'):sentence.find(',"')]
                elif 'Sir' in sentence[sentence.find(',"'):]:
                    speaker_said_part = sentence[sentence.find(',"') + 3:]
                    statement_part = sentence[sentence.find(' "'):sentence.find(',"') + 2]
            elif sentence.find(': "') != -1:
                if sentence.find(': "') != -1:
                    speaker_said_part = sentence[:sentence.find(': "')]
                    statement_part = sentence[sentence.find(': "'):]
                elif sentence.find(' "') != -1:
                    speaker_said_part = sentence[:sentence.find(' "')]
                    statement_part = sentence[sentence.find(' "'):]
            elif sentence.find(',"') != -1:
                speaker_said_part = sentence[sentence.find(',"') + 3:]
                statement_part = sentence[:sentence.find(',"') + 3]

            elif sentence.find(' "') != -1:
                speaker_said_part = sentence[:sentence.find(' "')]
                statement_part = sentence[sentence.find(' "'):]
            else:
                continue

            speaker_said_part_list.append(speaker_said_part)
            statement_sentence_list.append(statement_part)
        else:
            # In this place, i concerned about if the sentence is not a statement,
            # and there isn't function i can use in this step, so i just use regex
            # to match all the pattern with Sir and Sirs
            if 'Sir ' in sentence:
                name = re.findall('Sir\\s([A-Z][a-z]+)', sentence)
                for n in name:
                    name_set.add(n)
            if 'Sirs ' in sentence:
                name = re.findall('[A-Z][a-z]+', sentence.split('Sirs ')[1])
                for n in name:
                    name_set.add(n)


def add_Sir_if_dont_have(statement_sentence_list):
    '''
    Processing the statement part
    Split into an array of strings
    Remove punctuation, remove null
    Find the first Sir, start reading words starting with capital letters, if it is Sir then read the next one, if it is not Sir, the
    If it is Sir, then read the next one, if it is not Sir, then test whether the next word of the current word is Sir, if not, then replace the next word with 'Sir word' until it meets and or.

    Replace the word at the index position after and or with 'Sir word'.

    Splice strings to form strings
    Append back to the temporary list at the end of each round.
    '''
    tmp_list0 = []
    for statement_sentence in statement_sentence_list:
        statement_sentence = statement_sentence.split()
        # 去掉标点，去空
        statement_sentence = [re.sub('[,:\".?!]', '', element_without_quote) for element_without_quote in
                              statement_sentence]
        statement_sentence = [element for element in statement_sentence if element != '']

        # 找到第一个Sir...
        if 'Sir' in statement_sentence:
            first_sir_index = statement_sentence.index('Sir')

            for i in range(first_sir_index + 1, len(statement_sentence)):
                word = statement_sentence[i]

                if word == 'and' or word == 'or':
                    # statement_sentence[i + 1] = 'Sir ' + statement_sentence[i + 1]
                    if statement_sentence[i + 1] == 'I':
                        statement_sentence[i + 1] = 'Sir ' + statement_sentence[i + 1]
                    break

                if statement_sentence[i + 1][0].islower() and statement_sentence[i + 1] != 'and' and statement_sentence[
                    i + 1] != 'or':
                    break

                if word == 'Sir':
                    continue

                if word[0].isupper():
                    if i + 1 < len(statement_sentence) and statement_sentence[i + 1] != 'Sir' and \
                            statement_sentence[
                                i + 1] != 'or' and statement_sentence[i + 1] != 'and':
                        statement_sentence[i + 1] = 'Sir ' + statement_sentence[i + 1]
            statement_sentence = ' '.join(element for element in statement_sentence)
            tmp_list0.append(statement_sentence)

        elif 'I' in statement_sentence:
            statement_sentence = ' '.join(element for element in statement_sentence).replace('I', 'Sir I')
            tmp_list0.append(statement_sentence)

        elif 'us' in statement_sentence:
            statement_sentence = ' '.join(element for element in statement_sentence)
            tmp_list0.append(statement_sentence)

    return tmp_list0


def add_Sir_if_dont_have_speaker_part(speaker_said_part_list):
    '''
    Processing of speaker_said_part_list part
    Split into an array of strings
    Remove punctuation, remove blanks
    Find the first Sir, or Sirs, start to read the word that starts with a capital letter, if it's Sir then read the next one, if it's not Sir or Sirs, if it's a word that starts with a lowercase letter, skip it, if it's a word that starts with a capital letter (definitely not Sir or Sirs) replace it with the 'Sir word', until it encounters and or.

    Replace the word at the index position after and or with 'Sir word'.

    Splice strings to form strings
    Append back to the temporary list at the end of each round.
    '''
    tmp_list1 = []
    first_sir_index = 0
    first_sirs_index = 0
    for speaker_said_part in speaker_said_part_list:
        speaker_said_part = speaker_said_part.split()
        # 去掉标点，去空
        speaker_said_part = [re.sub('[,:\".?!]', '', element_without_quote) for element_without_quote in
                             speaker_said_part]
        speaker_said_part = [element for element in speaker_said_part if element != '']
        if first_sir_index or first_sirs_index:
            # 找到第一个Sir，或者Sirs...
            if first_sir_index:
                first_sir_index = speaker_said_part.index('Sir')
            if first_sirs_index:
                first_sirs_index = speaker_said_part.index('Sirs')
            if first_sir_index and first_sirs_index:
                first_index = min(first_sir_index, first_sirs_index)
            else:
                first_index = first_sir_index if first_sir_index else first_sirs_index

            for i in range(first_index + 1, len(speaker_said_part)):
                word = speaker_said_part[i]

                if word == 'and' or word == 'or':
                    break

                if word == 'Sir' or word == 'Sirs' or 'I':
                    continue

                if word[0].islower():
                    continue

                if word[0].isupper():
                    if i + 1 < len(speaker_said_part) and speaker_said_part[i + 1] != 'Sir' and speaker_said_part[
                        i + 1] != 'Sirs' and \
                            speaker_said_part[
                                i + 1] != 'or' and speaker_said_part[i + 1] != 'and':
                        speaker_said_part[i + 1] = 'Sir ' + speaker_said_part[i + 1]

        speaker_said_part = ' '.join(element for element in speaker_said_part)
        tmp_list1.append(speaker_said_part)
    return tmp_list1


# TODO: Whether or not to determine whether or not there is a Sir in speaker_part
def find_speaker_person(speaker_said_part_list):
    '''
    Find speaker_person
    Find the index of the last Sir, because it is the last Sir of speaker_part that is the speaker.
    '''
    for speaker_said_part in speaker_said_part_list:
        # 找最后一个Sir...
        # print(speaker_said_part.split()[::-1])
        # print(speaker_said_part.split()[::-1].index('Sir'))
        last_sir_index = speaker_said_part.split()[::-1].index('Sir') - 1
        # print(speaker_said_part.split()[::-1][last_sir_index])

        speaker_names.append(speaker_said_part.split()[::-1][last_sir_index])


def replace_I_in_statement(speaker_names, speaker_said_part_list, statement_sentence_list):
    '''
    Find mentioned person
    If 'Sir I' is in the statement, replace it with 'Sir speaker_name'.
    '''
    idx = 0
    tmp_list2 = []
    for speaker, statement in zip(speaker_said_part_list, statement_sentence_list):
        # print(speaker_names)
        # print(speaker_names[idx])
        # print(statement)
        if 'Sir I ' in statement:
            statement = statement.replace('Sir I ', f'Sir {speaker_names[idx]} ')
        idx += 1
        tmp_list2.append(statement)
    return tmp_list2


def find_all_names(speaker_said_part_list, statement_sentence_list):
    for speak, statement in zip(speaker_said_part_list, statement_sentence_list):
        speak = speak.split()
        statement = statement.split()
        speak_statement = speak + statement
        for idx in range(len(speak_statement) - 1):
            if speak_statement[idx] == 'Sir' or speak_statement[idx] == 'Sirs':
                name_set.add(speak_statement[idx + 1])
    # To reduce the redundant Sir or Sirs read for the name_set
    name_set.discard('Sir')
    name_set.discard('Sirs')

    ordered_name_set = sorted(name_set)
    return ordered_name_set


def knight_or_knave(statement_sentence_list):
    identity_list = []
    for statement_sentence in statement_sentence_list:
        identity = ''
        if 'Knaves' in statement_sentence or 'Knave' in statement_sentence:
            identity = 'knave'
        elif 'Knights' in statement_sentence or 'Knight' in statement_sentence:
            identity = 'knight'
        identity_list.append(identity)
    return identity_list

# TODO: Transfer all the words to lower case to simplify the code
def collect_principle(statement_sentence_list, statement_names):
    principle_list = []
    for idx, statement_sentence in enumerate(statement_sentence_list):
        length_mentioned_person = len(statement_names[idx])
        principle = ''
        if 'At least one' in statement_sentence or 'at least one' in statement_sentence and length_mentioned_person >= 2:
            principle = 'at least'
        elif 'At most' in statement_sentence or 'at most' in statement_sentence and length_mentioned_person >= 2:
            principle = 'at most'
        elif 'Exactly' in statement_sentence or 'exactly' in statement_sentence and length_mentioned_person >= 2:
            principle = 'exactly'
        elif 'All' in statement_sentence or 'all' in statement_sentence:
            principle = 'all'
        elif ' am ' in statement_sentence and length_mentioned_person == 1:
            principle += 'am'
        elif ('at least one' and 'at most one' and 'exactly one' and ' or ' and 'At least one' and 'At most one' and 'Exactly one') not in statement_sentence and 'is' in statement_sentence and length_mentioned_person == 1:
            principle = 'is'
        elif ' or ' in statement_sentence and 'is' in statement_sentence and length_mentioned_person >= 2:
            principle = 'or'
        elif ' and ' in statement_sentence and ' are ' in statement_sentence:
            principle = 'and'
        principle_list.append(principle)
    return principle_list


def find_pairs(speaker_names, identity_list, principle_list, statement_names):
    sir_statements_pairs = {}
    # Go through the data
    for idx in range(len(speaker_names)):
        speaker = speaker_names[idx]
        identity = identity_list[idx]
        principle = principle_list[idx]
        mentioned_people = statement_names[idx]

        # The speaker is not in the dictionary, create a new entry with the speaker as the key
        if speaker not in sir_statements_pairs:
            sir_statements_pairs[speaker] = [[[], [], ""]]
            # ADD INTO DICT
            sir_statements_pairs[speaker][0][0].extend(mentioned_people)
            sir_statements_pairs[speaker][0][1] = principle
            sir_statements_pairs[speaker][0][2] = identity
        # Append [mentioned_people, principle, identity] to the end of sir_statements_pairs[speaker] if the speaker is in the dictionary
        elif speaker in sir_statements_pairs:
            sir_statements_pairs[speaker].append([mentioned_people, principle, identity])

    return sir_statements_pairs

def update_names_list(truth_table_of_names_list, garbage):
    updated_list = []
    garbage_set = set(garbage)
    for name in truth_table_of_names_list:
        if name not in garbage_set:
            updated_list.append(name)
    return updated_list

def principle_handler(truth_table_of_names_list, all_names, speaker, *statement):
    name_except_speaker = []
    # 如果包括本人，从statement[0]中删除
    if speaker in statement[0]:
        for name in statement[0]:
            if name != speaker:
                name_except_speaker.append(name)
    else:
        name_except_speaker = statement[0]

    if not truth_table_of_names_list:
        return

    # 只有一个人，并且是说话者本人
    if statement[1] == 'am':
        # 如果这个人是骗子，则无解
        if statement[2] == 'knave':
            return
        elif statement[2] == 'knight':
            pass
    # 只有一个人，
    elif statement[1] == 'is':
        if statement[2] == 'knave':
            garbage = []
            for single_part in truth_table_of_names_list:
                for except_speaker in name_except_speaker:
                    if single_part[all_names.index(speaker)] == single_part[all_names.index(except_speaker)]:
                        garbage.append(single_part)
            truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
        elif statement[2] == 'knight':
            garbage = []
            for single_part in truth_table_of_names_list:
                for except_speaker in name_except_speaker:
                    if single_part[all_names.index(speaker)] != single_part[all_names.index(except_speaker)]:
                        garbage.append(single_part)
            truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
    elif statement[1] == 'all':
        if statement[2] == 'knave':
            garbage = []
            for single_part in truth_table_of_names_list:
                if single_part[all_names.index(speaker)] == 0:
                    cnt = 0
                    total = len(name_except_speaker)
                    for except_speaker in name_except_speaker:
                        if single_part[all_names.index(except_speaker)] == 0:
                            cnt += 1
                    if cnt == total:
                        garbage.append(single_part)
                elif single_part[all_names.index(speaker)] == 1:
                    garbage.append(single_part)
            truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
        elif statement[2] == 'knight':
            garbage = []
            for single_part in truth_table_of_names_list:
                if single_part[all_names.index(speaker)] == 1:
                    for except_speaker in name_except_speaker:
                        if single_part in truth_table_of_names_list and single_part[
                            all_names.index(except_speaker)] == 0:
                            garbage.append(single_part)
            truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
    elif statement[1] == 'and':
        if statement[2] == 'knave':
            garbage = []
            if speaker in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 1:
                        garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt == total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
            elif speaker not in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt == total:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
        elif statement[2] == 'knight':
            garbage = []
            if speaker in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 1:
                        for except_speaker in name_except_speaker:
                            if single_part in truth_table_of_names_list and single_part[
                                all_names.index(except_speaker)] == 0:
                                garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
            elif speaker not in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 1:
                        for except_speaker in name_except_speaker:
                            if single_part in truth_table_of_names_list and single_part[
                                all_names.index(except_speaker)] == 0:
                                garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        total = len(statement[0])
                        for except_speaker in name_except_speaker:
                            if single_part in truth_table_of_names_list and single_part[
                                all_names.index(except_speaker)] == 1:
                                cnt += 1
                                if cnt == total:
                                    garbage.append(single_part)

                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)

    elif statement[1] == 'at least' or statement[1] == 'or':
        if statement[2] == 'knave':
            if speaker in statement[0]:
                garbage = []
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 1:
                                cnt += 1
                        if cnt == total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)

            elif speaker not in statement[0]:
                garbage = []
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != 0:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 1:
                                cnt += 1
                        if cnt == total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)

        elif statement[2] == 'knight':
            if speaker in statement[0]:
                garbage = []
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
            elif speaker not in statement[0]:
                garbage = []
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt == total:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != total:
                            garbage.append(single_part)

                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)

    elif statement[1] == 'exactly':
        total = len(name_except_speaker)
        if statement[2] == 'knave':
            garbage = []
            if speaker in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt >= 1:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != 1:
                            garbage.append(single_part)
                truth_table_of_names_list = update_names_list(truth_table_of_names_list, garbage)
            elif speaker not in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt == 1:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != 1:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)

        elif statement[2] == 'knight':
            garbage = []
            if speaker in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt0 = 0
                        cnt1 = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                            elif single_part[all_names.index(except_speaker)] == 1:
                                cnt1 += 1
                        if total == cnt0 or cnt1 > 1:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt != total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
            elif speaker not in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt0 = 0
                        cnt1 = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                            elif single_part[all_names.index(except_speaker)] == 1:
                                cnt1 += 1
                        if total == cnt0 or cnt1 == total:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 1:
                                cnt += 1
                        if cnt != 1:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)

    elif statement[1] == 'at most':
        if statement[2] == 'knave':
            if speaker in statement[0]:
                garbage = []
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt0 = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                        if cnt0 >= 1:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt0 = 0
                        cnt1 = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                            elif single_part[all_names.index(except_speaker)] == 1:
                                cnt1 += 1
                        if cnt0 != 1 and not cnt1 == total:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
            elif speaker not in statement[0]:
                garbage = []
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt0 = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                        if cnt0 >= 2:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt0 = 0
                        cnt1 = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                            elif single_part[all_names.index(except_speaker)] == 1:
                                cnt1 += 1
                        if cnt0 == 1 or cnt1 == total:
                            pass
                        else:
                            garbage.append(single_part)
                truth_table_of_names_list=update_names_list(truth_table_of_names_list,garbage)
        # list_from_set['Catherine', 'Crystal', 'Dale', 'Eduardo', 'Florence', 'Hugh', 'Luis', 'Norman']
        # list_person[1]
        elif statement[2] == 'knight':
            garbage = []
            if speaker in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 1:
                                cnt += 1
                        if cnt > 1:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt += 1
                        if cnt == total:
                            pass
                        else:
                            garbage.append(single_part)
                truth_table_of_names_list = update_names_list(truth_table_of_names_list, garbage)
            elif speaker not in statement[0]:
                for single_part in truth_table_of_names_list:
                    if single_part[all_names.index(speaker)] == 0:
                        cnt1 = 0
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 1:
                                cnt1 += 1
                        if cnt1 > 1:
                            pass
                        else:
                            garbage.append(single_part)
                    elif single_part[all_names.index(speaker)] == 1:
                        cnt0 = 0
                        cnt1 = 0
                        total = len(name_except_speaker)
                        for except_speaker in name_except_speaker:
                            if single_part[all_names.index(except_speaker)] == 1:
                                cnt1 += 1
                            if single_part[all_names.index(except_speaker)] == 0:
                                cnt0 += 1
                        if cnt1 == 1 or cnt0 == total:
                            pass
                        else:
                            garbage.append(single_part)
                truth_table_of_names_list = update_names_list(truth_table_of_names_list, garbage)
    return truth_table_of_names_list


# {'Hugh', 'Liam', 'Rodney', 'Miller', 'Erika', 'Ray', 'Elaine', 'Darlene', 'Naomi', 'Julia', 'Ruby', 'Nathaniel'}

# split the sentences
all_sentences = find_single_sentences(combined_text)

partition(all_sentences)

statement_sentence_list = add_Sir_if_dont_have(statement_sentence_list)

speaker_said_part_list = add_Sir_if_dont_have_speaker_part(speaker_said_part_list)

find_speaker_person(speaker_said_part_list)

statement_sentence_list = replace_I_in_statement(speaker_names, speaker_said_part_list, statement_sentence_list)

all_names = find_all_names(speaker_said_part_list, statement_sentence_list)

print(f"The Sirs are: {' '.join(name for name in all_names)}")

# replace us to all_names
tmp = []
for statement_sentence in statement_sentence_list:
    if ' us ' in statement_sentence:
        statement_sentence = statement_sentence.replace(' us ',' '+ ' '.join(['Sir ' + name for name in all_names])+' ')
    tmp.append(statement_sentence)

statement_sentence_list = tmp

statement_names = []
for element in statement_sentence_list:
    tmp = []
    words = element.split()
    for idx in range(len(words) - 1):
        if words[idx] == 'Sir' or words[idx] == 'Sirs':
            if words[idx + 1][0].isupper():
                tmp.append(words[idx + 1])
    statement_names.append(tmp)

identity_list = knight_or_knave(statement_sentence_list)

principle_list = collect_principle(statement_sentence_list, statement_names)

sir_statements_pairs = find_pairs(speaker_names, identity_list, principle_list, statement_names)

# initial the truth table
number_of_all_names = len(all_names)
truth_table_of_names_list = [tuple(map(int, f'{i:0{number_of_all_names}b}')) for i in range(2 ** number_of_all_names)]

for speaker, statement in sir_statements_pairs.items():
    if len(statement) > 1:
        for item in [*statement]:
            truth_table_of_names_list = principle_handler(truth_table_of_names_list, all_names, speaker, *item)
    elif len(statement) == 1:
        new_data = [*statement[0]]
        truth_table_of_names_list = principle_handler(truth_table_of_names_list, all_names, speaker, *new_data)

if truth_table_of_names_list:
    length_result = len(truth_table_of_names_list)
    if length_result == 1:
        print('There is a unique solution:')
        for index in range(len(truth_table_of_names_list[0])):
            if truth_table_of_names_list[0][index] == 0:
                print(f'Sir {all_names[index]} is a Knave.')
            elif truth_table_of_names_list[0][index] == 1:
                print(f'Sir {all_names[index]} is a Knight.')
    elif length_result > 1:
        print(f'There are {length_result} solutions.')
else:
    print(f'There is no solution.')

# print(truth_table_of_names_list)