from circular_linked_list import CircularLinkedList
import random 
from time import sleep
import os
import keyboard

"""Create a spinning game that uses multiple linked lists to store various emojis.
The game should allow players to trigger a random spinning, that utilizes the nature of a circular linked list
to simulate continuous spinning. 
"""


def simulate_slot_machine():
    """
    Creates three circular linked lists (reels), fills them with emojis, 
    simulates a spin, and returns the resulting emoji combination.
    """
    
    # 1. Define the Emojis for the Reels
    # We use different sets/orders to make the machine slightly more unpredictable.
    all_emojis = ["🍒", "🍋", "🍊", "🍇", "🔔", "💰", "💎", "⭐"]
    
    # 2. Create the three Circular Linked Lists (Reels)
    reel1 = CircularLinkedList()
    reel2 = CircularLinkedList()
    reel3 = CircularLinkedList()
    
    # Create slightly different lists for each reel by rotating the emoji list
    emojis_r1 = all_emojis * 5  # Add a lot of items for a good simulation
    emojis_r2 = all_emojis[2:] + all_emojis[:2] # Shifted list
    emojis_r2 = emojis_r2 * 5
    emojis_r3 = all_emojis[4:] + all_emojis[:4] # Another shifted list
    emojis_r3 = emojis_r3 * 5
    
    # 3. Add Emojis to the Linked Lists
    for emoji in emojis_r1:
        reel1.append(emoji)
    for emoji in emojis_r2:
        reel2.append(emoji)
    for emoji in emojis_r3:
        reel3.append(emoji)


    # print(f"✅ Slot Machine initialized .")
    # os.system('clear')

    one = reel1.head
    two = reel2.head
    three = reel3.head

    try:
        while True:
            os.system('clear')
            print(one.get_data(), two.get_data(), three.get_data())
            sleep(0.1)

            one = one.get_next()
            two = two.get_next()
            three = three.get_next()

    except KeyboardInterrupt:
        pass

    for i in range(5):
        os.system('clear')
        print(one.get_data(), two.get_data(), three.get_data())
        sleep(0.2)

        two = two.get_next()
        three = three.get_next()

    for i in range(5):
        os.system('clear')
        print(one.get_data(), two.get_data(), three.get_data())
        sleep(0.3)


        three = three.get_next()

    os.system('clear')
    print(one.get_data(), two.get_data(), three.get_data())






    # 4. Simulate the Spin
    
    # Determine a random number of steps for each reel to land on a random position.
    # The minimum steps ensures the illusion of spinning.
    min_steps = 10 
    max_steps = 50 
    
    # Random steps for each reel
    steps1 = random.randint(min_steps, max_steps)
    steps2 = random.randint(min_steps, max_steps)
    steps3 = random.randint(min_steps, max_steps)

  

if __name__ == '__main__':

    simulate_slot_machine()

from linked_list import Linked_List
import random

colors = Linked_List()

for i in range(12):
    random_n = random.randint(130,135) # generate the color number
    colors.add_last(random_n) # add the color to the linked list
colors.pretty_print()

create the new_node

if the list is empty
	set head to the new node

else if the head is greater than the new_node's data
    set the new_nodes's next to the head
    set head to the new node

else:
    initialize current_node to the head
    loop while next isn't None and next's data is less or equal to the new_node's data
        move the current_node to the next node

    set the new_node's next to current_node's next
    set current_node's next to the new_node

from linked_list import Linked_List
import random

colors = Linked_List()

for i in range(12):
    random_n = random.randint(130,135) # generate the color number
    colors.insert(random_n) # add the color to the linked list
colors.pretty_print()

if the list is empty
	return True

else
    initialize current_node to the head
    loop while next isn't None
        if the current_node's data is greater than the next nodes's data
            return False
        move the current_node to the next node

    return True

if x and y are the same
	return without doing anything

set x_prev variable to None (storing the node before x)
set x_node variable to None (stores the x node)
set y_prev variable to None (storing the node before y)
set y_node variable to None (stores the y node)

set prev variable to None
set curr variable to the head 

while curr is not None
    if curr's data matches x
        set x_prev to prev
        set x_node to curr
    if curr's data matches y
        set y_prev to prev
        set y_node to curr
    
    set prev to curr
    set curr to curr's next

if either x or y is not in the list
    return without doing anything

if x is the head
    set the head to y_node
else
    set the next pointer of x_prev to y_node

if y is the head
    set the head to x_node
else
    set the next pointer of y_prev to x_node

use a temp variable to store y_node's next
set y_node's next to x_node's next
set x_node's next to temp
return
 

from linked_list import Linked_List
from random import shuffle

# set the range for the colors
start = 130
end = 135

# generate the color numbers
nums = []
for i in range(start,end):
    nums.append(i)

# shuffle the color numbers
shuffle(nums)

# create the linked list for the colors
colors = Linked_List()

# add the colors to the linked list
for num in nums:
    colors.add_last(num) 


while colors.is_ordered() == False:
    colors.pretty_print()
    try:
        x = int(input(f"Enter a color number to swap out ({start}-{end}): "))
        y = int(input(f"Enter a color number to swap out ({start}-{end}): "))
        colors.swap(x, y)

    except:
        print(f"Invalid input. Please enter integers between {start} and {end}.")

print("🌈 Nice! The colors are now in order")
colors.pretty_print()