A LinkedList implementation in Python

class Link:
    def __init__(self, value):
        self.val = value
        self.next = None

    def __repr__(self):
        return f"{self.val} "

    def __str__(self):
        return self.__repr__()

# TODO : Implement Non-recursive solutions and string representations in recursive solutions.


class LinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.length = 0

    def __str__(self):
        curr = self.head
        linklist = ""
        while curr:
            linklist += str(curr) + ' '
            curr = curr.next
        return 'Linklist : ' + linklist

    def __len__(self):
        curr = self.head
        next = self.head
        size = 0
        while curr and next:
            if not next.next:
                size += 1
                return size
            else:
                size += 2
            curr = curr.next
            next = next.next.next
        return size

    def insert(self, key):
        if not self.head:
            self.head = Link(key)
            self.tail = self.head
        else:
            node = Link(key)
            self.tail.next = node
            self.tail = node
        self.length += 1

    def delete(self, key):
        if not self.head:
            return False
        elif self.head.val == key:
            self.head = self.head.next
        else:
            curr = self.head
            prev = None
            while curr and curr.val != key:
                prev = curr
                curr = curr.next
            if curr:
                prev.next = curr.next
                self.length -= 1
                return True
        return False

    def print_reverse(self, node):
        if node:
            self.print_reverse(node.next)
            print(str(node))

    def do_reverse(self):
        prev = None
        curr = self.head
        n = None
        while curr:
            n = curr.next
            curr.next = prev
            prev = curr
            curr = n
        self.head = prev

    def delete_a_node_pointer(self):
        pass

    def find_middle_element(self):
        curr = self.head
        next = self.head
        while curr and next:
            if not next.next:
                return curr.val,
            elif next.next and not next.next.next:
                return curr.val, curr.next.val
            curr = curr.next
            next = next.next.next

    def hascycle(self):
        slow = self.head
        fast = self.head
        while slow and fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if fast is slow:
                return True
        return False

    def create_a_cycle(self):
        index = 0
        curr = self.head
        while curr:
            if index == 4:
                break
            curr = curr.next
            index += 1
        self.tail.next = curr

    def find_start_of_the_cycle(self):
        slow = self.head
        fast = self.head
        cycle = False
        while slow and fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if fast is slow:
                cycle = True
                break
        if cycle:
            curr = self.head
            while curr and fast and curr is not fast:
                curr = curr.next
                fast = fast.next
            return curr
        else:
            return None

    def removeNthFromEnd(self, n):
        pass


def test_main():
    linklist = LinkedList()
    linklist.insert(2)
    # linklist.insert(4)
    # linklist.insert(3)
    # linklist.insert(-3)
    #linklist.insert(-92)
    print(str(linklist))
    # linklist.delete(2)
    # linklist.delete(3)
    # linklist.delete(4)
    # Don't print once the list has a cycle as it will loop for forever
    #linklist.create_a_cycle()
    # print(str(linklist))
    print('HasCycle : ' , linklist.hascycle())
    print('Cycle : ', str(linklist.tail), '->', linklist.find_start_of_the_cycle())
    print('Middle Element : ', linklist.find_middle_element())
    linklist.do_reverse()
    print('Reversed', str(linklist))
    print('Length LinkedList : ', str(len(linklist)))


if __name__ == '__main__':
    test_main()