# Syntaxkontroll
import string


class Node:
    def __init__(self, value=None, next=None):
        self.value = value  # Håller ett värde för noden
        self.next = next    # Sätter en pekare på vilken nod som är nästa

    def __str__(self):
        return self.value   # Returnerar värdet på noden


class LinkedQ:
    def __init__(self):
        self.__first = None     # Sätter en pekare på den första noden i kön
        self.__last = None      # Sätter en pekare på den sista noden i kön

    def enqueue(self, value):   # Metod för att lägga till noder i kön

        new_node = Node(value)

        if self.isEmpty():
            self.__first = new_node
            self.__last = new_node
        else:
            self.__last.next = new_node     # Den senaste noden pekar nu på den nya tillagda noden
            self.__last = new_node          # Den nya tillagda noden tilldelas den sista platsen

    def dequeue(self):                      # Metod för att ta ut den första noden i kön
        value = self.__first.value
        self.__first = self.__first.next    # Sätter den som är efter till först i kön
        return value

    def isEmpty(self):                      # Kollar om kön är tom
        return self.__first is None

    def peek(self):
        peek = self.__first.next.value
        return peek

class Syntaxfel(Exception):
    pass



def LETTER(q):
    """
    :param letter: ett tecken
    :return: True or False
    """
    tecken = q.dequeue()
    ALPHABET = string.ascii_uppercase

    if tecken.isupper() is True and tecken in ALPHABET:
        print(tecken)
        return
    raise Syntaxfel("Saknad stor bokstav")




def letter(q):
    """
    Kollar om ett tecken är en liten bokstav och finns med i lilla engelska alfabetet
    :param letter: Ett tecken
    :return: True or False
    """
    tecken = q.dequeue()
    alphabet = string.ascii_lowercase

    if tecken.islower() is True and tecken in alphabet:
        print(tecken)
        return
    raise Syntaxfel("Ska vara en stor bokstav")


def num(q):
    """
    Kollar om ett tecken är ett nummer och större än 2
    :param q:
    :return:
    """
    next = q.peek()

    number = q.dequeue()

    if type(number) is int and number >= 2:
        print(number)
        # while type(next) is int and next >= 2:
        #     if not q.isEmpty():
        #         q.dequeue()
        #         print(next)
        return

    raise Syntaxfel("för litet tal vid radfel")


def atom(q):
    """
    returnerar
    :param q:
    :return:
    """
    alphabet = alphabetmaker()

    next = q.peek()

    LETTER(q)
    if next in alphabet and next is not None:
        letter(q)
        return
    else:
        return

    # if uppest.islower() is True:
    #     letter(q)
    # else:
    #     LETTER(q)

def molekyl(q):
    """

    :param q: kön med värden
    :return:
    """
    # next = q.peek()
    # tecken = q.__first
    while not q.isEmpty():
        atom(q)
        num(q)


def kollaomrätt():

    q=LinkedQ()
    q.enqueue("A")
    q.enqueue("a")
    q.enqueue(4)
    q.enqueue("B")
    q.enqueue(7)
    q.enqueue("C")
    q.enqueue("c")
    q.enqueue(3)
    q.enqueue(3)

    try:
        molekyl(q)
        print("Följer syntax")
    except Syntaxfel as fel:
        print(str(fel))

def alphabetmaker():
    alph =string.ascii_lowercase
    list=[]
    for i in alph:
        list.append(i)
    return list


kollaomrätt()

#
# def readMening(q):
#     readSats(q)
#     if q.peek() == ".":
#         q.dequeue()
#     else:
#         readKonj(q)
#         readMening(q)
#
#
#
# def readSats(q):
#     readSubj(q)
#     readPred(q)
#
# def readSubj(q):
#     word = q.dequeue()
#     if word == "JAG":
#         return
#     if word == "DU":
#         return
#     raise Grammatikfel("Fel subjekt: " + word)
#
# def readPred(q):
#     word = q.dequeue()
#     if word == "TROR":
#         return
#     if word == "VET":
#         return
#     raise Grammatikfel("Fel predikat: " + word)
#
# def readKonj(q):
#     word = q.dequeue()
#     if word == "ATT":
#         return
#     if word == "OCH":
#         return
#     raise Grammatikfel("Fel konjunktion: " + word)
#
# def printQueue(q):
#     while not q.isEmpty():
#         word = q.dequeue()
#         print(word, end = " ")
#     print()
#
# def storeSentence(mening):
#     q = WordQueue()
#     mening = mening.split()
#     for ordet in mening:
#         q.enqueue(ordet)
#     q.enqueue(".")
#     return q
#
#
# def kollaGrammatiken(mening):
#     q = storeSentence(mening)
#
#     try:
#         readMening(q)
#         return "Följer syntaxen!"
#     except Grammatikfel as fel:
#         return str(fel) + " före " + str(q)
#
# def main():
#     q = WordQueue()
#     mening = input("Skriv en mening: ")
#     resultat = kollaGrammatiken(mening)
#     print(resultat)
#
# if __name__ == "__main__":
#     main()