import gradio as gr
import io
import json
import random
import contextlib
import traceback
from datetime import datetime

APP_TITLE = "PCEP Python Learning Academy"
PASS_MARK = 70

LESSONS = {
    "1. Python Fundamentals": {
        "block": "Computer Programming and Python Fundamentals",
        "weight": "18%",
        "content": """
### Learning goals
- Understand what programming is.
- Understand interpreter, syntax, comments, indentation, variables, and literals.
- Write your first Python statements.

### Key explanation
Python is an interpreted programming language. You write instructions, and the Python interpreter runs them line by line.

Python uses indentation to show code structure. This is important for `if`, `for`, `while`, and functions.

### Example
```python
# This is a comment
print("Hello, Python!")
age = 20
print(age)
```

### Common exam points
- Python is case-sensitive.
- Comments start with `#`.
- Indentation is part of Python syntax.
- Variable names should be meaningful and follow Python naming rules.
""",
        "starter_code": "print('Hello, PCEP learner!')\nname = 'Student'\nprint('Welcome', name)",
    },
    "2. Variables and Data Types": {
        "block": "Computer Programming and Python Fundamentals",
        "weight": "18%",
        "content": """
### Learning goals
- Use variables to store values.
- Recognize integers, floats, strings, and Booleans.
- Convert values using `int()`, `float()`, and `str()`.

### Example
```python
age = 25          # int
price = 9.99      # float
name = "Ali"      # str
passed = True     # bool

print(type(age))
print(int("10") + 5)
```

### Common exam points
- `10` is an integer.
- `10.0` is a float.
- `"10"` is a string.
- `True` and `False` are Boolean values.
""",
        "starter_code": "x = '10'\ny = 5\nprint(int(x) + y)",
    },
    "3. Operators": {
        "block": "Computer Programming and Python Fundamentals",
        "weight": "18%",
        "content": """
### Learning goals
- Use arithmetic, comparison, logical, assignment, and string operators.
- Understand operator priority.

### Example
```python
print(2 + 3)
print(2 ** 3)
print(7 // 2)
print(7 % 2)
print(5 > 3 and 2 < 4)
print("Py" + "thon")
```

### Common exam points
- `**` means exponentiation.
- `//` means floor division.
- `%` gives the remainder.
- `and`, `or`, and `not` are Boolean operators.
""",
        "starter_code": "a = 7\nb = 2\nprint(a // b)\nprint(a % b)",
    },
    "4. Input and Output": {
        "block": "Computer Programming and Python Fundamentals",
        "weight": "18%",
        "content": """
### Learning goals
- Use `print()` for output.
- Use `input()` for user input.
- Convert input values when needed.

### Example
```python
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print("Hello", name)
print("Next year you will be", age + 1)
```

### Common exam points
- `input()` always returns a string.
- Use `int()` or `float()` before doing numeric calculation.
- `print()` supports `sep=` and `end=`.
""",
        "starter_code": "print('Python', 'PCEP', sep=' - ')\nprint('Hello', end=' ')\nprint('World')",
    },
    "5. Conditional Statements": {
        "block": "Control Flow – Conditional Blocks and Loops",
        "weight": "29%",
        "content": """
### Learning goals
- Use `if`, `elif`, and `else`.
- Build Boolean expressions.
- Understand nested conditions.

### Example
```python
score = 75

if score >= 70:
    print("Pass")
elif score >= 50:
    print("Borderline")
else:
    print("Fail")
```

### Common exam points
- Conditions must evaluate to `True` or `False`.
- `elif` means else-if.
- Indentation is required inside each block.
""",
        "starter_code": "score = 75\nif score >= 70:\n    print('Pass')\nelse:\n    print('Try again')",
    },
    "6. Loops": {
        "block": "Control Flow – Conditional Blocks and Loops",
        "weight": "29%",
        "content": """
### Learning goals
- Use `while` loops and `for` loops.
- Use `range()`.
- Understand `break` and `continue`.

### Example
```python
for i in range(5):
    print(i)

count = 0
while count < 3:
    print(count)
    count += 1
```

### Common exam points
- `range(5)` produces 0, 1, 2, 3, 4.
- `break` exits a loop.
- `continue` skips to the next iteration.
""",
        "starter_code": "for i in range(1, 6):\n    print(i)",
    },
    "7. Lists, Tuples, Dictionaries, and Strings": {
        "block": "Data Collections – Tuples, Dictionaries, Lists, and Strings",
        "weight": "25%",
        "content": """
### Learning goals
- Use lists, tuples, dictionaries, and strings.
- Use indexing and slicing.
- Understand mutability.

### Example
```python
items = ["pen", "book", "bag"]
print(items[0])
items.append("pencil")

person = {"name": "Ali", "age": 20}
print(person["name"])

word = "Python"
print(word[0])
print(word[1:4])
```

### Common exam points
- Lists are mutable.
- Tuples are immutable.
- Dictionary values are accessed using keys.
- Strings are immutable.
""",
        "starter_code": "numbers = [3, 1, 2]\nnumbers.append(4)\nprint(sorted(numbers))\nprint(numbers[0:2])",
    },
    "8. Functions": {
        "block": "Functions and Exceptions",
        "weight": "28%",
        "content": """
### Learning goals
- Define and call functions.
- Use parameters and return values.
- Understand `None`.

### Example
```python
def add(a, b):
    return a + b

result = add(3, 4)
print(result)
```

### Common exam points
- A function is defined with `def`.
- `return` sends a value back to the caller.
- A function without `return` returns `None`.
""",
        "starter_code": "def greet(name):\n    return 'Hello ' + name\n\nprint(greet('PCEP'))",
    },
    "9. Exceptions": {
        "block": "Functions and Exceptions",
        "weight": "28%",
        "content": """
### Learning goals
- Understand runtime errors.
- Use `try` and `except`.
- Handle common exceptions safely.

### Example
```python
try:
    number = int("abc")
except ValueError:
    print("Invalid number")
```

### Common exam points
- `ValueError` happens when a value has the wrong format.
- `ZeroDivisionError` happens when dividing by zero.
- Exceptions prevent the whole program from crashing if handled properly.
""",
        "starter_code": "try:\n    print(10 / 0)\nexcept ZeroDivisionError:\n    print('Cannot divide by zero')",
    },
    "10. Mock Exam": {
        "block": "All PCEP blocks",
        "weight": "100%",
        "content": """
### Learning goals
- Review all major PCEP topics.
- Practise exam-style thinking.
- Identify weak areas before the actual exam.

Use the **Mock Exam** tab to attempt a 30-question quiz.
""",
        "starter_code": "print('Ready for the mock exam!')",
    },
}

QUESTION_BANK = [
    {"topic":"Fundamentals","q":"Which symbol starts a single-line comment in Python?","choices":["//","#","--","/*"],"answer":"#","explain":"Python single-line comments start with #."},
    {"topic":"Fundamentals","q":"Python uses indentation mainly to show what?","choices":["Code block structure","File size","Program speed","Package version"],"answer":"Code block structure","explain":"Indentation defines blocks such as if, loops, and functions."},
    {"topic":"Variables","q":"What is the type of 3.14?","choices":["int","float","str","bool"],"answer":"float","explain":"Numbers with decimal points are usually floats."},
    {"topic":"Variables","q":"What does input() return?","choices":["int","float","str","bool"],"answer":"str","explain":"input() always returns a string unless you convert it."},
    {"topic":"Operators","q":"What is the result of 7 // 2?","choices":["3","3.5","1","4"],"answer":"3","explain":"// performs floor division."},
    {"topic":"Operators","q":"What is the result of 2 ** 3?","choices":["5","6","8","9"],"answer":"8","explain":"** means exponentiation."},
    {"topic":"Operators","q":"Which operator gives the remainder?","choices":["/","//","%","**"],"answer":"%","explain":"% is the modulo operator."},
    {"topic":"Input/Output","q":"Which function displays output?","choices":["show()","print()","display()","output()"],"answer":"print()","explain":"print() displays output to the console."},
    {"topic":"Conditionals","q":"Which keyword checks another condition after if fails?","choices":["elseif","elif","else if","then"],"answer":"elif","explain":"Python uses elif for else-if logic."},
    {"topic":"Conditionals","q":"What is the result of 5 > 3?","choices":["True","False","5","3"],"answer":"True","explain":"5 is greater than 3."},
    {"topic":"Loops","q":"What values are produced by range(3)?","choices":["1,2,3","0,1,2","0,1,2,3","3 only"],"answer":"0,1,2","explain":"range(3) starts at 0 and stops before 3."},
    {"topic":"Loops","q":"Which keyword exits a loop immediately?","choices":["stop","exit","break","continue"],"answer":"break","explain":"break exits the nearest loop."},
    {"topic":"Loops","q":"Which keyword skips the current loop iteration?","choices":["skip","continue","break","pass"],"answer":"continue","explain":"continue jumps to the next iteration."},
    {"topic":"Lists","q":"Which method adds an item to the end of a list?","choices":["add()","append()","push()","insert_end()"],"answer":"append()","explain":"append() adds an item to the end of a list."},
    {"topic":"Lists","q":"What is numbers[0] for numbers = [10, 20, 30]?","choices":["10","20","30","Error"],"answer":"10","explain":"Python indexing starts at 0."},
    {"topic":"Tuples","q":"Which collection is immutable?","choices":["list","tuple","dictionary","set item"],"answer":"tuple","explain":"Tuples cannot be changed after creation."},
    {"topic":"Dictionaries","q":"How do you access the value for key 'name' in d?","choices":["d.name","d['name']","d(name)","d->name"],"answer":"d['name']","explain":"Dictionary values are accessed using keys in square brackets."},
    {"topic":"Strings","q":"What is 'Python'[0]?","choices":["P","y","Python","Error"],"answer":"P","explain":"The first character is at index 0."},
    {"topic":"Strings","q":"Are Python strings mutable?","choices":["Yes","No","Only short strings","Only numeric strings"],"answer":"No","explain":"Strings are immutable."},
    {"topic":"Functions","q":"Which keyword defines a function?","choices":["function","def","fun","define"],"answer":"def","explain":"Python uses def to define functions."},
    {"topic":"Functions","q":"What does a function return if it has no return statement?","choices":["0","False","None","Empty string"],"answer":"None","explain":"A function without return returns None."},
    {"topic":"Functions","q":"Which keyword sends a result back from a function?","choices":["send","return","yield only","break"],"answer":"return","explain":"return gives a result back to the caller."},
    {"topic":"Exceptions","q":"Which exception often occurs when int('abc') is executed?","choices":["TypeError","ValueError","ZeroDivisionError","NameError"],"answer":"ValueError","explain":"'abc' cannot be converted to an integer."},
    {"topic":"Exceptions","q":"Which exception occurs for 10 / 0?","choices":["ValueError","ZeroDivisionError","IndexError","KeyError"],"answer":"ZeroDivisionError","explain":"Division by zero raises ZeroDivisionError."},
    {"topic":"Operators","q":"What is True and False?","choices":["True","False","None","Error"],"answer":"False","explain":"and returns True only when both sides are True."},
    {"topic":"Operators","q":"What is not True?","choices":["True","False","None","Error"],"answer":"False","explain":"not reverses the Boolean value."},
    {"topic":"Lists","q":"What does len([1, 2, 3]) return?","choices":["2","3","4","Error"],"answer":"3","explain":"len() returns the number of items."},
    {"topic":"Dictionaries","q":"Which method returns dictionary keys?","choices":["keys()","items()","values()","index()"],"answer":"keys()","explain":"keys() returns the dictionary keys."},
    {"topic":"Strings","q":"What is 'abc' + 'def'?","choices":["abcdef","abc def","Error","6"],"answer":"abcdef","explain":"+ concatenates strings."},
    {"topic":"Variables","q":"Which is a valid Python variable name?","choices":["2name","first_name","first-name","class"],"answer":"first_name","explain":"Variable names cannot start with a number, contain hyphen, or use keywords."},
    {"topic":"Fundamentals","q":"Which statement is case-sensitive in Python?","choices":["Name and name are different","Name and name are same","Only functions are case-sensitive","Only strings are case-sensitive"],"answer":"Name and name are different","explain":"Python identifiers are case-sensitive."},
    {"topic":"Input/Output","q":"What does print('A', 'B', sep='-') display?","choices":["A B","A-B","AB","A, B"],"answer":"A-B","explain":"sep='-' places a hyphen between output items."},
]

progress = {"completed_lessons": [], "quiz_scores": {}, "exam_history": []}
current_exam = []


def get_lesson(topic):
    data = LESSONS[topic]
    return f"""
# {topic}
**PCEP block:** {data['block']}  
**Approximate exam weight:** {data['weight']}

{data['content']}
""", data["starter_code"]


def mark_complete(topic):
    if topic not in progress["completed_lessons"]:
        progress["completed_lessons"].append(topic)
    return dashboard()


def run_code(code):
    safe_builtins = {
        "print": print, "range": range, "len": len, "int": int, "float": float, "str": str,
        "bool": bool, "list": list, "tuple": tuple, "dict": dict, "set": set, "sum": sum,
        "min": min, "max": max, "sorted": sorted, "type": type, "enumerate": enumerate,
        "abs": abs, "round": round, "True": True, "False": False, "None": None
    }
    env = {"__builtins__": safe_builtins}
    output = io.StringIO()
    try:
        with contextlib.redirect_stdout(output):
            exec(code, env, env)
        result = output.getvalue()
        return result if result else "Code ran successfully with no printed output."
    except Exception:
        return "Error:\n" + traceback.format_exc(limit=2)


def get_practice_question(topic_filter):
    pool = QUESTION_BANK if topic_filter == "All" else [q for q in QUESTION_BANK if q["topic"] == topic_filter]
    if not pool:
        pool = QUESTION_BANK
    q = random.choice(pool)
    return q["q"], gr.update(choices=q["choices"], value=None), json.dumps(q)


def check_practice_answer(choice, q_json):
    if not q_json:
        return "Please generate a question first."
    q = json.loads(q_json)
    if choice == q["answer"]:
        progress["quiz_scores"].setdefault(q["topic"], []).append(1)
        return f"✅ Correct. {q['explain']}"
    progress["quiz_scores"].setdefault(q["topic"], []).append(0)
    return f"❌ Incorrect. Correct answer: **{q['answer']}**. {q['explain']}"


def start_exam():
    global current_exam
    current_exam = random.sample(QUESTION_BANK, min(30, len(QUESTION_BANK)))
    outputs = []
    for i, q in enumerate(current_exam):
        outputs.append(gr.update(label=f"Q{i+1}. {q['q']}", choices=q["choices"], value=None, visible=True))
    return outputs + ["Exam started. Answer all questions, then click Submit Exam."]


def submit_exam(*answers):
    if not current_exam:
        return "Please start an exam first.", dashboard()
    correct = 0
    topic_total = {}
    topic_correct = {}
    review = []
    for i, q in enumerate(current_exam):
        ans = answers[i]
        topic_total[q["topic"]] = topic_total.get(q["topic"], 0) + 1
        if ans == q["answer"]:
            correct += 1
            topic_correct[q["topic"]] = topic_correct.get(q["topic"], 0) + 1
        else:
            review.append(f"Q{i+1}: {q['q']}\nYour answer: {ans}\nCorrect answer: {q['answer']}\nExplanation: {q['explain']}")
    score = round(correct / len(current_exam) * 100, 1)
    status = "PASS" if score >= PASS_MARK else "REVIEW NEEDED"
    progress["exam_history"].append({"date": datetime.now().strftime("%Y-%m-%d %H:%M"), "score": score})
    weak = []
    for topic, total in topic_total.items():
        pct = round(topic_correct.get(topic, 0) / total * 100)
        if pct < 70:
            weak.append(f"{topic}: {pct}%")
    feedback = f"# Exam Result\nScore: **{score}%** ({correct}/{len(current_exam)})\n\nStatus: **{status}**\n\n"
    if weak:
        feedback += "## Weak areas to review\n" + "\n".join([f"- {w}" for w in weak]) + "\n\n"
    if review:
        feedback += "## Wrong-answer review\n" + "\n\n".join(review[:10])
    else:
        feedback += "Excellent work. No wrong answers in this attempt."
    return feedback, dashboard()


def dashboard():
    total_lessons = len(LESSONS)
    completed = len(progress["completed_lessons"])
    completion = round(completed / total_lessons * 100)
    quiz_attempts = sum(len(v) for v in progress["quiz_scores"].values())
    quiz_correct = sum(sum(v) for v in progress["quiz_scores"].values())
    quiz_pct = round(quiz_correct / quiz_attempts * 100, 1) if quiz_attempts else 0
    best_exam = max([x["score"] for x in progress["exam_history"]], default=0)
    lines = [
        "# Progress Dashboard",
        f"Lessons completed: **{completed}/{total_lessons}** ({completion}%)",
        f"Practice quiz accuracy: **{quiz_pct}%** ({quiz_correct}/{quiz_attempts})",
        f"Best mock exam score: **{best_exam}%**",
        "",
        "## Completed lessons",
    ]
    lines += [f"- {x}" for x in progress["completed_lessons"]] or ["- None yet"]
    lines.append("\n## Recommended next step")
    if completion < 100:
        lines.append("Complete all lessons, then attempt the mock exam.")
    elif best_exam < PASS_MARK:
        lines.append("Review weak areas and retake the mock exam.")
    else:
        lines.append("Good progress. Continue practising timed questions before the real exam.")
    return "\n".join(lines)


def export_progress():
    return json.dumps(progress, indent=2)

with gr.Blocks(title=APP_TITLE, theme=gr.themes.Soft()) as demo:
    gr.Markdown(f"# {APP_TITLE}\nBeginner-friendly Python learning and PCEP exam preparation platform.")

    with gr.Tab("Learn"):
        topic = gr.Dropdown(list(LESSONS.keys()), value="1. Python Fundamentals", label="Choose lesson")
        lesson_md = gr.Markdown()
        complete_btn = gr.Button("Mark lesson as completed")
        dash_from_lesson = gr.Markdown()
        topic.change(get_lesson, topic, [lesson_md, gr.State()])
        demo.load(get_lesson, topic, [lesson_md, gr.State()])
        complete_btn.click(mark_complete, topic, dash_from_lesson)

    with gr.Tab("Code Playground"):
        code_topic = gr.Dropdown(list(LESSONS.keys()), value="1. Python Fundamentals", label="Load starter code")
        code_box = gr.Code(label="Python Code", language="python", lines=12)
        run_btn = gr.Button("Run Code")
        code_output = gr.Textbox(label="Output", lines=10)
        code_topic.change(lambda t: LESSONS[t]["starter_code"], code_topic, code_box)
        demo.load(lambda: LESSONS["1. Python Fundamentals"]["starter_code"], None, code_box)
        run_btn.click(run_code, code_box, code_output)

    with gr.Tab("Practice Quiz"):
        practice_topic = gr.Dropdown(["All"] + sorted(set(q["topic"] for q in QUESTION_BANK)), value="All", label="Question topic")
        q_text = gr.Markdown("Click Generate Question to begin.")
        q_choice = gr.Radio(label="Choose your answer", choices=[])
        q_state = gr.State("")
        gen_btn = gr.Button("Generate Question")
        check_btn = gr.Button("Check Answer")
        feedback = gr.Markdown()
        gen_btn.click(get_practice_question, practice_topic, [q_text, q_choice, q_state])
        check_btn.click(check_practice_answer, [q_choice, q_state], feedback)

    with gr.Tab("Mock Exam"):
        gr.Markdown("Start a randomized 30-question PCEP-style mock exam. Suggested time limit: 45 minutes.")
        start_btn = gr.Button("Start Mock Exam")
        exam_status = gr.Markdown()
        exam_radios = []
        for i in range(30):
            exam_radios.append(gr.Radio(label=f"Q{i+1}", choices=[], visible=True))
        submit_btn = gr.Button("Submit Exam")
        exam_result = gr.Markdown()
        exam_dash = gr.Markdown()
        start_btn.click(start_exam, None, exam_radios + [exam_status])
        submit_btn.click(submit_exam, exam_radios, [exam_result, exam_dash])

    with gr.Tab("Dashboard"):
        dash = gr.Markdown()
        refresh_btn = gr.Button("Refresh Dashboard")
        export_btn = gr.Button("Export Progress JSON")
        export_box = gr.Textbox(label="Progress JSON", lines=12)
        demo.load(dashboard, None, dash)
        refresh_btn.click(dashboard, None, dash)
        export_btn.click(export_progress, None, export_box)

if __name__ == "__main__":
    demo.launch()