def er_blokkert(nummer, oppdrag):
    blokkerere = oppdrag[nummer][1]
    for blokkerer in blokkerere:
        if oppdrag[blokkerer][0]:
            return True
    
    return False


def kan_spilles(nummer, oppdrag):
    if nummer not in oppdrag:
        return False
    
    if er_blokkert(nummer, oppdrag):
        return False
    
    aapnere = oppdrag[nummer][2]
    
    for aapner in aapnere:
        if not oppdrag[aapner][0]:
            return False
    
    return True



def test_er_blokkert():
    # Test 1: Oppdrag som er blokkert
    oppdrag1 = {
        1: [True, []],
        2: [False, [1]],  # 1 blokkerer 2 hvis 1 er fullf?rt
    }
    assert er_blokkert(2, oppdrag1) == True, "Test 1 feilet: Oppdrag 2 er blokkert av fullf?rt oppdrag 1"

    # Test 2: Oppdrag som ikke er blokkert
    oppdrag2 = {
        1: [False, []],
        2: [False, [1]],  # 1 blokkerer 2, men 1 er ikke fullf?rt
    }
    assert er_blokkert(2, oppdrag2) == False, "Test 2 feilet: Oppdrag 2 er ikke blokkert siden oppdrag 1 ikke er fullf?rt"

    # Test 3: Oppdrag uten blokkerere
    oppdrag3 = {
        1: [False, []],
        2: [False, []],  # Ingen blokkerere for oppdrag 2
    }
    assert er_blokkert(2, oppdrag3) == False, "Test 3 feilet: Oppdrag 2 har ingen blokkerere"

    print("Alle tester for er_blokkert best?tt!")


def test_kan_spilles():
    # Test 1: Oppdrag som finnes, ikke er blokkert, og kan spilles
    oppdrag1 = {
        1: [True, [], []],
        2: [False, [], [1]],  # 1 m? v?re fullf?rt for at 2 kan spilles
    }
    assert kan_spilles(2, oppdrag1) == True, "Test 1 feilet: Oppdrag 2 kan spilles siden oppdrag 1 er fullf?rt"

    # Test 2: Oppdrag som er blokkert og kan ikke spilles
    oppdrag2 = {
        1: [True, [], []],
        2: [False, [1], []],  # 1 blokkerer 2 hvis fullf?rt
    }
    assert kan_spilles(2, oppdrag2) == False, "Test 2 feilet: Oppdrag 2 kan ikke spilles fordi det er blokkert av oppdrag 1"

    # Test 3: Oppdrag som krever at andre oppdrag er fullf?rt for ? bli l?st opp
    oppdrag3 = {
        1: [False, [], []],
        2: [False, [], [1]],  # 1 m? v?re fullf?rt for at 2 kan spilles
    }
    assert kan_spilles(2, oppdrag3) == False, "Test 3 feilet: Oppdrag 2 kan ikke spilles siden oppdrag 1 ikke er fullf?rt"

    # Test 4: Oppdrag som ikke finnes
    oppdrag4 = {
        1: [True, [], []]
    }
    assert kan_spilles(3, oppdrag4) == False, "Test 4 feilet: Oppdrag 3 finnes ikke i oppdrag, og kan ikke spilles"

    # Test 5: Oppdrag uten krav eller blokkerere kan spilles
    oppdrag5 = {
        1: [False, [], []]
    }
    assert kan_spilles(1, oppdrag5) == True, "Test 5 feilet: Oppdrag 1 har ingen krav og ingen blokkerere, og kan spilles"

    print("Alle tester for kan_spilles best?tt!")


# Kj?rer testene
test_er_blokkert()
test_kan_spilles()