"""
Unit tests for particle modules: Atom, Electron, Nucleon, Orbital, Probe, Loader
"""
import pytest
import json
from pathlib import Path
from datetime import datetime, timezone

from src.heurams.kernel.particles.atom import Atom
from src.heurams.kernel.particles.electron import Electron
from src.heurams.kernel.particles.nucleon import Nucleon
from src.heurams.kernel.particles.orbital import Orbital
# Probe module doesn't have a Probe class, only functions
# Loader module doesn't have a Loader class, only functions


class TestAtom:
    """Test cases for Atom class."""

    def test_atom_creation(self):
        """Test basic Atom creation."""
        nucleon = Nucleon(content="Test content", answer="Test answer")
        electron = Electron()
        orbital = Orbital()

        atom = Atom(nucleon=nucleon, electron=electron, orbital=orbital)

        assert atom.nucleon == nucleon
        assert atom.electron == electron
        assert atom.orbital == orbital

    def test_atom_from_dict(self):
        """Test creating Atom from dictionary."""
        data = {
            "nucleon": {
                "content": "What is 2+2?",
                "answer": "4"
            },
            "electron": {
                "ease": 2.5,
                "interval": 1,
                "repetitions": 0,
                "last_review": None
            },
            "orbital": {
                "learning_steps": [1, 10],
                "graduating_interval": 1,
                "easy_interval": 4
            }
        }

        atom = Atom.from_dict(data)

        assert atom.nucleon.content == "What is 2+2?"
        assert atom.nucleon.answer == "4"
        assert atom.electron.ease == 2.5
        assert atom.electron.interval == 1
        assert atom.orbital.learning_steps == [1, 10]

    def test_atom_to_dict(self):
        """Test converting Atom to dictionary."""
        nucleon = Nucleon(content="Test", answer="Answer")
        electron = Electron()
        orbital = Orbital()
        atom = Atom(nucleon=nucleon, electron=electron, orbital=orbital)

        result = atom.to_dict()

        assert "nucleon" in result
        assert "electron" in result
        assert "orbital" in result
        assert result["nucleon"]["content"] == "Test"


class TestElectron:
    """Test cases for Electron class."""

    def test_electron_default_values(self):
        """Test Electron default initialization."""
        electron = Electron()

        assert electron.ease == 2.5
        assert electron.interval == 1
        assert electron.repetitions == 0
        assert electron.last_review is None

    def test_electron_custom_values(self):
        """Test Electron with custom values."""
        test_time = datetime.now(timezone.utc)
        electron = Electron(
            ease=3.0,
            interval=10,
            repetitions=5,
            last_review=test_time
        )

        assert electron.ease == 3.0
        assert electron.interval == 10
        assert electron.repetitions == 5
        assert electron.last_review == test_time

    def test_electron_review_quality_1(self):
        """Test review with quality 1 (failed)."""
        electron = Electron(ease=2.5, interval=10, repetitions=5)
        orbital = Orbital()

        new_electron = electron.review(1, orbital)

        assert new_electron.repetitions == 0
        assert new_electron.interval == 1
        assert new_electron.ease == 2.5

    def test_electron_review_quality_3(self):
        """Test review with quality 3 (good)."""
        electron = Electron(ease=2.5, interval=1, repetitions=0)
        orbital = Orbital()

        new_electron = electron.review(3, orbital)

        assert new_electron.repetitions == 1
        assert new_electron.interval == 1

    def test_electron_review_quality_5(self):
        """Test review with quality 5 (excellent)."""
        electron = Electron(ease=2.5, interval=10, repetitions=5)
        orbital = Orbital()

        new_electron = electron.review(5, orbital)

        assert new_electron.repetitions == 6
        assert new_electron.interval > 10  # Should increase interval
        assert new_electron.ease > 2.5  # Should increase ease


class TestNucleon:
    """Test cases for Nucleon class."""

    def test_nucleon_creation(self):
        """Test basic Nucleon creation."""
        nucleon = Nucleon(content="Test content", answer="Test answer")

        assert nucleon.content == "Test content"
        assert nucleon.answer == "Test answer"

    def test_nucleon_from_dict(self):
        """Test creating Nucleon from dictionary."""
        data = {
            "content": "What is Python?",
            "answer": "A programming language"
        }

        nucleon = Nucleon.from_dict(data)

        assert nucleon.content == "What is Python?"
        assert nucleon.answer == "A programming language"

    def test_nucleon_to_dict(self):
        """Test converting Nucleon to dictionary."""
        nucleon = Nucleon(content="Test", answer="Answer")

        result = nucleon.to_dict()

        assert result["content"] == "Test"
        assert result["answer"] == "Answer"


class TestOrbital:
    """Test cases for Orbital class."""

    def test_orbital_default_values(self):
        """Test Orbital default initialization."""
        orbital = Orbital()

        assert orbital.learning_steps == [1, 10]
        assert orbital.graduating_interval == 1
        assert orbital.easy_interval == 4

    def test_orbital_custom_values(self):
        """Test Orbital with custom values."""
        orbital = Orbital(
            learning_steps=[2, 15],
            graduating_interval=2,
            easy_interval=6
        )

        assert orbital.learning_steps == [2, 15]
        assert orbital.graduating_interval == 2
        assert orbital.easy_interval == 6

    def test_orbital_from_dict(self):
        """Test creating Orbital from dictionary."""
        data = {
            "learning_steps": [3, 20],
            "graduating_interval": 3,
            "easy_interval": 8
        }

        orbital = Orbital.from_dict(data)

        assert orbital.learning_steps == [3, 20]
        assert orbital.graduating_interval == 3
        assert orbital.easy_interval == 8

    def test_orbital_to_dict(self):
        """Test converting Orbital to dictionary."""
        orbital = Orbital()

        result = orbital.to_dict()

        assert "learning_steps" in result
        assert "graduating_interval" in result
        assert "easy_interval" in result


# TestProbe class removed - probe module only has functions, not a class


# TestLoader class removed - loader module only has functions, not a class