# --- Day 16: Ticket Translation ---

# As you're walking to yet another connecting flight, you realize that one of
# the legs of your re-routed trip coming up is on a high-speed train. However,
# the train ticket you were given is in a language you don't understand. You
# should probably figure out what it says before you get to the train station
# after the next flight.

# Unfortunately, you can't actually read the words on the ticket. You can,
# however, read the numbers, and so you figure out the fields these tickets
# must have and the valid ranges for values in those fields.

# You collect the rules for ticket fields, the numbers on your ticket, and the
# numbers on other nearby tickets for the same train service (via the airport
# security cameras) together into a single document you can reference (your
# puzzle input).

# The rules for ticket fields specify a list of fields that exist somewhere on
# the ticket and the valid ranges of values for each field. For example, a rule
# like class: 1-3 or 5-7 means that one of the fields in every ticket is named
# class and can be any value in the ranges 1-3 or 5-7 (inclusive, such that 3
# and 5 are both valid in this field, but 4 is not).

# Each ticket is represented by a single line of comma-separated values. The
# values are the numbers on the ticket in the order they appear; every ticket
# has the same format. For example, consider this ticket:

# .--------------------------------------------------------.
# | ????: 101    ?????: 102   ??????????: 103     ???: 104 |
# |                                                        |
# | ??: 301  ??: 302             ???????: 303      ??????? |
# | ??: 401  ??: 402           ???? ????: 403    ????????? |
# '--------------------------------------------------------'

# Here, ? represents text in a language you don't understand. This ticket might
# be represented as 101,102,103,104,301,302,303,401,402,403; of course, the
# actual train tickets you're looking at are much more complicated. In any
# case, you've extracted just the numbers in such a way that the first number
# is always the same specific field, the second number is always a different
# specific field, and so on - you just don't know what each position actually
# means!

# Start by determining which tickets are completely invalid; these are tickets
# that contain values which aren't valid for any field. Ignore your ticket for
# now.

# For example, suppose you have the following notes:

# class: 1-3 or 5-7
# row: 6-11 or 33-44
# seat: 13-40 or 45-46

# your ticket:
# 7,1,14

# nearby tickets:
# 7,3,47
# 40,4,50
# 55,2,20
# 38,6,12

# It doesn't matter which position corresponds to which field; you can identify
# invalid nearby tickets by considering only whether tickets contain values
# that are not valid for any field. In this example, the values on the first
# nearby ticket are all valid for at least one field. This is not true of the
# other three nearby tickets: the values 4, 55, and 12 are are not valid for
# any field. Adding together all of the invalid values produces your ticket
# scanning error rate: 4 + 55 + 12 = 71.

# Consider the validity of the nearby tickets you scanned. What is your ticket
# scanning error rate?

from typing import Set

with open("files/P16.txt", "r") as f:
    rules_raw, my_ticket, nearby_tickets = [
        f.split("\n") for f in f.read().strip().split("\n\n")
    ]


def part_1() -> None:
    rules = []
    for rule in rules_raw:
        name = rule.split(": ")[0]
        valid_numbers = set()
        for range_numbers in rule.split(": ")[1].split(" or "):
            numbers = [int(number) for number in range_numbers.split("-")]
            first, last = range(*numbers).start, range(*numbers).stop
            list_numbers = list(range(first, last + 1))
            for number in list_numbers:
                valid_numbers.add(number)
        rules.append([name, valid_numbers])

    # Create a single set with all rules
    all_rules = set()
    for rule in rules:
        all_rules |= rule[1]

    all_tickets = [list(map(int, o.split(","))) for o in nearby_tickets[1:]]

    ticket_scanning_error_rate = sum(
        [
            ticket
            for ticket_numbers in all_tickets
            for ticket in ticket_numbers
            if ticket not in all_rules
        ]
    )

    print(f"The ticket scanning error rate is {ticket_scanning_error_rate}")


# --- Part Two ---

# Now that you've identified which tickets contain invalid values, discard
# those tickets entirely. Use the remaining valid tickets to determine which
# field is which.

# Using the valid ranges for each field, determine what order the fields appear
# on the tickets. The order is consistent between all tickets: if seat is the
# third field, it is the third field on every ticket, including your ticket.

# For example, suppose you have the following notes:

# class: 0-1 or 4-19
# row: 0-5 or 8-19
# seat: 0-13 or 16-19

# your ticket:
# 11,12,13

# nearby tickets:
# 3,9,18
# 15,1,5
# 5,14,9

# Based on the nearby tickets in the above example, the first position must be
# row, the second position must be class, and the third position must be seat;
# you can conclude that in your ticket, class is 12, row is 11, and seat is 13.

# Once you work out which field is which, look for the six fields on your
# ticket that start with the word departure. What do you get if you multiply
# those six values together?


def from_part_1():
    # from part_1
    rules = []
    for rule in rules_raw:
        name = rule.split(": ")[0]
        valid_numbers = set()
        for range_numbers in rule.split(": ")[1].split(" or "):
            numbers = [int(number) for number in range_numbers.split("-")]
            first, last = range(*numbers).start, range(*numbers).stop
            list_numbers = list(range(first, last + 1))
            for number in list_numbers:
                valid_numbers.add(number)
        rules.append([name, valid_numbers])

    all_rules = set()
    for rule in rules:
        all_rules |= rule[1]

    return rules, all_rules


def remove_invalid(all_rules):
    valid_tickets = []
    for line in nearby_tickets[1:]:
        valid = True
        for ticket in [int(t) for t in line.split(",")]:
            if ticket not in all_rules:
                valid = False
                break
        if valid:
            valid_tickets.append(line)
    return valid_tickets


def check_validity(rules, ticket_values):
    # check validity of sets
    possibles = []
    for c in rules:
        possibles.append([c[0], []])
        for idx, ticket in enumerate(ticket_values):
            valid = True
            for value in ticket:
                if value not in c[1]:
                    valid = False
                    break
            if valid:
                possibles[-1][1].append(idx)
    return possibles


def get_ordered_fields(sorted_possibles):
    # get each field and its respective order
    ordered_fields = []
    for idx, (field, values) in enumerate(sorted_possibles):
        # first field
        if len(values) == 1:
            ordered_fields.append([field, values[0]])
        else:
            value = [
                v for v in values if v not in sorted_possibles[idx - 1][1]
            ][0]
            ordered_fields.append([field, value])
    return ordered_fields


def part_2() -> None:
    rules, all_rules = from_part_1()

    valid_tickets = remove_invalid(all_rules)

    # collect 20 sets of all respective values
    ticket_values = [set() for x in range(len(rules))]
    for line in valid_tickets:
        index = 0
        for element in line.split(","):
            ticket_values[index].add(int(element))
            index += 1

    possibles = check_validity(rules, ticket_values)

    # sort possibles by the length of values each set holds
    sorted_possibles = sorted(possibles, key=lambda l: (len(l[1]), l))

    sorted_fields = get_ordered_fields(sorted_possibles)

    # parse "my ticket"
    myticket = [
        int(v) for elements in my_ticket[1:] for v in elements.split(",")
    ]

    res = 1
    for (field, idx) in sorted_fields:
        if field.startswith("departure"):
            res *= myticket[idx]
    print(f"The final result is {res}")


if __name__ == "__main__":
    part_1()
    part_2()