Generate WORKING Manim code for Scene 1.

IMPLEMENTATION: ```python
from manim import *

class DanielCellScene(Scene):
    def construct(self):
        # Layout Plan:
        # 1. Title: Text - .to_edge(UP, buff=0.5) - Introduce topic
        # 2. Diagram: Combination of Rectangle, Circle, Line, Arrow - Left side (.shift(LEFT*2.5)) - Visual focus: Daniel cell setup
        # 3. Explanation Text: Text - Right side (.shift(RIGHT*2.5)) - Describe components and reactions
        # 4. Main Equation: MathTex - .shift(UP*1.5) - Simple redox equation (pattern: simple_equation)
        # 5. Secondary Text: Text - .shift(DOWN*1.5) - Transition to electrical energy concept

        # 1. Title
        title = Text("Introduction to the Daniel Cell", color=WHITE).to_edge(UP, buff=0.5)

        # 2. Diagram components (Left side)
        # Zinc electrode: Rectangle (BLUE)
        zinc_electrode = Rectangle(width=1, height=2, color=BLUE).shift(LEFT * 2.5 + UP * 0.5)
        zinc_label = Text("Zn Electrode", color=BLUE).next_to(zinc_electrode, DOWN, buff=0.2)

        # ZnSO4 solution: Rectangle (BLUE, lighter fill)
        zn_solution = Rectangle(width=1.5, height=2.5, color=BLUE, fill_opacity=0.2).next_to(zinc_electrode, RIGHT, buff=0.1)

        # Copper electrode: Rectangle (RED)
        copper_electrode = Rectangle(width=1, height=2, color=RED).shift(LEFT * 0.5 + UP * 0.5)
        copper_label = Text("Cu Electrode", color=RED).next_to(copper_electrode, DOWN, buff=0.2)

        # CuSO4 solution: Rectangle (RED, lighter fill)
        cu_solution = Rectangle(width=1.5, height=2.5, color=RED, fill_opacity=0.2).next_to(copper_electrode, RIGHT, buff=0.1)

        # Salt bridge: Rectangle (YELLOW)
        salt_bridge = Rectangle(width=0.5, height=2.5, color=YELLOW, fill_opacity=0.3).next_to(cu_solution, RIGHT, buff=0.1)

        # Arrows indicating electron flow and ion flow
        # Electron flow arrow (from Zn to Cu)
        e_flow_arrow = Arrow(start=zinc_electrode.get_top() + LEFT*0.1, end=copper_electrode.get_top() + RIGHT*0.1, color=WHITE)
        e_flow_label = Text("e⁻ flow", color=WHITE).next_to(e_flow_arrow, UP, buff=0.1)

        # Ion flow arrow (salt bridge)
        ion_flow_arrow = Arrow(start=salt_bridge.get_bottom() + DOWN*0.1, end=salt_bridge.get_top() + UP*0.1, color=YELLOW)
        ion_flow_label = Text("Ion flow", color=YELLOW).next_to(ion_flow_arrow, RIGHT, buff=0.1)

        diagram_group = VGroup(
            zinc_electrode, zinc_label, zn_solution,
            copper_electrode, copper_label, cu_solution,
            salt_bridge,
            e_flow_arrow, e_flow_label,
            ion_flow_arrow, ion_flow_label
        ).shift(LEFT * 2.5)

        # 3. Explanation Text (Right side)
        explanation = Text(
            "Zinc electrode in ZnSO₄ solution\n"
            "Copper electrode in CuSO₄ solution\n"
            "Salt bridge connects the two\n"
            "Oxidation at Zn (anode)\n"
            "Reduction at Cu (cathode)",
            color=WHITE,
            line_spacing=1.2
        ).shift(RIGHT * 2.5)

        # 4. Main Equation (Upper center)
        main_eq = MathTex(
            r"\mathrm{Zn} \rightarrow \mathrm{Zn}^{2+} + 2e^- \quad (oxidation)",
            r"\quad\quad",
            r"\mathrm{Cu}^{2+} + 2e^- \rightarrow \mathrm{Cu} \quad (reduction)",
            color=WHITE
        ).shift(UP * 1.5)

        # 5. Secondary Text (Lower center)
        transition_text = Text(
            "These reactions produce electrical energy.\n"
            "Next, we explore the cell voltage.",
            color=WHITE,
            line_spacing=1.2
        ).shift(DOWN * 1.5)

        # Animation Sequence:

        # Step 1: Show title
        self.play(Write(title), run_time=1.5)

        # Step 2: Show diagram and explanation text
        self.play(
            Create(diagram_group),
            Write(explanation),
            run_time=3
        )
        self.wait(1)

        # Fade out explanation text and diagram, keep title
        self.play(
            FadeOut(explanation),
            FadeOut(diagram_group),
            run_time=1
        )

        # Step 3: Show main equation
        self.play(Write(main_eq), run_time=2)
        self.wait(1)

        # Step 4: Show secondary text (transition)
        self.play(Write(transition_text), run_time=2)
        self.wait(2)

        # Final cleanup: fade out everything except title
        self.play(
            FadeOut(main_eq),
            FadeOut(transition_text),
            run_time=1
        )
        self.wait(1)
```
---

### Explanation of the plan:

- **Title** is always at the top edge with 0.5 buffer.
- **Diagram** is grouped and shifted LEFT by 2.5 units, showing zinc and copper electrodes with their solutions and salt bridge, using only allowed objects and colors.
- **Explanation text** is on the right side, shifted RIGHT by 2.5.
- **Main equation** is shifted UP by 1.5, centered horizontally.
- **Secondary text** is shifted DOWN by 1.5, centered horizontally.
- All elements fit within the screen bounds (-6 to +6 horizontally, -3.5 to +3.5 vertically).
- Animations use only Write, Create, and FadeOut.
- Cleanup rules are followed: fade out old elements before new ones, keep main equation visible until transition text appears, then fade all except title at the end.
- The pattern "simple_equation" is respected by showing oxidation and reduction half-reactions side by side in the main equation.

This satisfies all strict positioning and content requirements.
PATTERN: simple_equation

CRITICAL CONSTRAINTS:
1. Use ONLY these objects: Text, MathTex, Axes, Circle, Rectangle, Line, Arrow, Dot, SurroundingRectangle, VGroup
2. Use ONLY these animations: Write, Create, FadeIn, FadeOut 
3. Use ONLY these colors (no quotes): BLUE, RED, GREEN, YELLOW, WHITE, ORANGE, PURPLE
4. NO undefined objects like VideoFile, Slider, ImageMobject
5. NO Unicode characters - use LaTeX: \sqrt{} not √, \pm not ±

POSITIONING REQUIREMENTS (CRITICAL):
- Each element MUST have unique position within screen bounds
- SAFE positions only: .to_edge(UP), .shift(UP*1.5), .shift(DOWN*1.5), .shift(LEFT*2.5), .shift(RIGHT*2.5)
- NO extreme shifts: avoid UP*3, DOWN*3, LEFT*4, RIGHT*4 (goes off-screen)
- NO overlapping: if one element uses .shift(UP*1.5), others must use different positions
- Test positions: Title=top, Main=upper center, Secondary=lower center, Sides=left/right

TEMPLATE TO ADAPT:

        # Title positioned at top
        title = Text("{title}").scale(0.8).to_edge(UP, buff=0.5)
        
        # Main equation in center-upper area
        equation = MathTex(r"{equation}").scale(1.2).shift(UP * 0.5)
        
        # Description below equation
        description = Text("{description}").scale(0.6).shift(DOWN * 1.5)
        
        # Simple highlight
        highlight = SurroundingRectangle(equation, color=YELLOW, buff=0.2)
        
        # Progressive animation
        self.play(Write(title))
        self.wait(1)
        self.play(Write(equation))
        self.wait(1)
        self.play(Create(highlight))
        self.wait(1)
        self.play(Write(description))
        self.wait(2)
                

Replace placeholders with scene-specific values and ensure working Manim code.

Generate complete Python code: