import streamlit as st
import io
import sys

# Set up the layout of the app
st.title("Intro to Python: Interactive Learning")
st.write("Welcome to the Python learning platform! Explore the core concepts of Python programming with practical examples, and test them interactively.")

# Helper function to create an expanded explanation
def create_explanation(title, content):
    with st.expander(f"Explanation: {title}"):
        st.markdown(content)

# Helper function to execute code and capture output
def run_code(user_code):
    # Create StringIO object to capture output
    output = io.StringIO()
    # Redirect stdout to capture print statements
    sys.stdout = output
    try:
        # Execute the user's code
        exec(user_code, {})
        # Return the captured output
        result = output.getvalue()
        return result, None
    except Exception as e:
        return None, str(e)
    finally:
        # Reset stdout
        sys.stdout = sys.__stdout__

# 1. Basic Syntax and Variables
st.subheader("1. Basic Syntax and Variables")
code1 = '''name = "Alice"
age = 25
height = 5.6

print(f"My name is {name}, I am {age} years old and {height} feet tall.")
'''
st.code(code1, language="python")

create_explanation("Basic Syntax and Variables", """
In this example, we introduce **variables**, which are placeholders for storing data in Python. We create three variables:
- `name` stores a string (`"Alice"`),
- `age` stores an integer (`25`),
- `height` stores a float (`5.6`).

Next, we use **formatted string literals** (also known as f-strings) to combine these variables into a sentence and print it. The `print()` function outputs the message to the console. This is the fundamental way of creating variables and displaying information in Python.
""")

# Try it yourself box
st.write("### Try it Yourself:")
user_code1 = st.text_area("Example 1: Paste or modify the code and hit 'Run' to see the output.", value=code1, height=150, key="1")

if st.button("Run Example 1 Code"):
    result, error = run_code(user_code1)
    if result:
        st.success("Code ran successfully!")
        st.text(result)
    elif error:
        st.error(f"Error: {error}")

# 2. Control Flow: If-Else Statements
st.subheader("2. Control Flow: If-Else Statements")
code2 = '''temperature = 30

if temperature > 25:
    print("It's a hot day.")
else:
    print("It's a cool day.")
'''
st.code(code2, language="python")

create_explanation("Control Flow: If-Else Statements", """
**Control flow** allows you to make decisions in your code using conditions. The `if-else` statement checks if a condition is true:
- In this example, the condition is whether `temperature` is greater than `25`.
- If the condition is true, Python will execute the first block of code (`print("It's a hot day.")`).
- If the condition is false, Python executes the second block (`print("It's a cool day.")`).

Conditions use **comparison operators** like `>`, `<`, `==`, etc. Control flow is essential for writing dynamic, decision-based programs.
""")

# Try it yourself box
st.write("### Try it Yourself:")
user_code2 = st.text_area("Example 2: Paste or modify the code and hit 'Run' to see the output.", value=code2, height=150, key="2")

if st.button("Run Example 2 Code"):
    result, error = run_code(user_code2)
    if result:
        st.success("Code ran successfully!")
        st.text(result)
    elif error:
        st.error(f"Error: {error}")

# 3. Loops: For and While
st.subheader("3. Loops: For and While")
code3 = '''numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(f"Number: {number}")

count = 5
while count > 0:
    print(f"Countdown: {count}")
    count -= 1
'''
st.code(code3, language="python")

create_explanation("Loops: For and While", """
**Loops** allow you to repeat tasks. In this example, we demonstrate two types of loops:
- **For loop**: The `for` loop iterates over a list of numbers (`numbers`), printing each item in the list. This loop is commonly used when you know in advance how many times you want to iterate.
- **While loop**: The `while` loop continues as long as a specified condition is `True`. In this case, it counts down from `5` to `0`. This loop is useful when the number of iterations isn't known beforehand, but depends on a condition.

Loops are fundamental for automating repetitive tasks and processing sequences of data.
""")

# Try it yourself box
st.write("### Try it Yourself:")
user_code3 = st.text_area("Example 3: Paste or modify the code and hit 'Run' to see the output.", value=code3, height=150, key="3")

if st.button("Run Example 3 Code"):
    result, error = run_code(user_code3)
    if result:
        st.success("Code ran successfully!")
        st.text(result)
    elif error:
        st.error(f"Error: {error}")

# 4. Functions: Defining and Using Functions
st.subheader("4. Functions: Defining and Using Functions")
code4 = '''def add_numbers(a, b):
    return a + b

result = add_numbers(10, 20)
print(f"The result is: {result}")
'''
st.code(code4, language="python")

create_explanation("Functions: Defining and Using Functions", """
A **function** is a block of code that performs a specific task and can be reused multiple times. Functions allow us to structure our code for better readability and efficiency. Here's what's happening:
- We define a function `add_numbers(a, b)` which takes two arguments (`a` and `b`) and returns their sum.
- Then, we call this function with two numbers, `10` and `20`, and store the result in the variable `result`.
- Finally, we print the result.

Functions help make your code more modular and reusable by avoiding repetition.
""")

# Try it yourself box
st.write("### Try it Yourself:")
user_code4 = st.text_area("Example 4: Paste or modify the code and hit 'Run' to see the output.", value=code4, height=150, key="4")

if st.button("Run Example 4 Code"):
    result, error = run_code(user_code4)
    if result:
        st.success("Code ran successfully!")
        st.text(result)
    elif error:
        st.error(f"Error: {error}")

# 5. Lists and Dictionaries
st.subheader("5. Basic Data Structures: Lists and Dictionaries")
code5 = '''fruits = ["apple", "banana", "cherry"]
print(f"First fruit: {fruits[0]}")

student = {"name": "John", "age": 22, "major": "Computer Science"}
print(f"Student name: {student['name']}")
'''
st.code(code5, language="python")

create_explanation("Basic Data Structures: Lists and Dictionaries", """
In Python, **data structures** are used to store and organize data. Two common structures are:
- **Lists**: Ordered collections of items (e.g., numbers, strings). You can access items by their index. In the example, `fruits[0]` retrieves the first item, `"apple"`.
- **Dictionaries**: Unordered collections of key-value pairs. In the example, `student['name']` retrieves the value associated with the key `'name'`, which is `"John"`.

These structures are essential for storing and managing data in your programs, and you’ll frequently use them in everyday coding.
""")

# Try it yourself box
st.write("### Try it Yourself:")
user_code5 = st.text_area("Example 5: Paste or modify the code and hit 'Run' to see the output.", value=code5, height=150, key="5")

if st.button("Run Example 5 Code"):
    result, error = run_code(user_code5)
    if result:
        st.success("Code ran successfully!")
        st.text(result)
    elif error:
        st.error(f"Error: {error}")

# Footer
st.write("This app is an educational tool to help you learn basic Python concepts. Keep exploring and practicing to master the language!")