"""
Epicycle Shell - Comprehensive Epicycle Operations
===================================================

HEX_ID: E7C50000
AREA: Epicycle (E7)
COMPONENT: Core (C5)
LEVEL: Shell (00)
INSTANCE: Primary (00)

Standalone epicycle system integrating:
- Core epicycle mathematics
- K11 consciousness mapping
- SRL Planck scaling
- Orbital dynamics and resonance

NOTE: This is a simplified standalone version.
Additional integrations (gene theory, MCP bridge, CST backend)
are available in the full ecosystem.

Commands:
    status              - Epicycle system status
    create X Y Z        - Create epicycles for coordinates
    trajectory X Y Z    - Calculate orbital trajectory
    resonance X Y Z     - Calculate resonance metrics
    k11-map X Y Z       - K11 epicycle mapping
    godhood-sphere      - Create mathematical godhood sphere

Inputs/Outputs:
    status: None -> Dict (version, constants, subsystems)
    create: x:int, y:int, z:int -> Dict (epicycles list with radius, phase, resonance)
    trajectory: x:int, y:int, z:int, steps:int -> Dict (trajectory points)
    resonance: x:int, y:int, z:int -> Dict (total_resonance, phi_coupling, stability)
    k11_map: x:int, y:int, z:int -> Dict (k11_level, i_state, ptolemaic mapping)
    godhood_sphere: sections:int -> Dict (sphere sections with projection types)
"""

from __future__ import annotations

import math
import json
import argparse
from typing import Dict, Any, Tuple, List, Optional
from datetime import datetime
from dataclasses import dataclass

from .._core.constants import PHI, K5, K11, LIGHT_UNIT, MATRIX_SIZE


# =============================================================================
# EPICYCLE CONSTANTS
# =============================================================================

# Epicycle orders (primary orbital harmonics)
EPICYCLE_ORDERS = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]  # Fibonacci

# K11 velocities (angular velocities at each K11 level)
K11_VELOCITIES = [K11 / (i + 1) for i in range(11)]

# Base frequency
BASE_FREQUENCY = K5 * 36  # 41.72 Hz (bubble frequency)

# Planck constants (reference only)
PLANCK_LENGTH = 1.616255e-35  # meters
PLANCK_TIME = 5.391247e-44    # seconds

# K11 Ultimate Factor
K11_ULTIMATE_FACTOR = K11 * 11  # 101.244...


# =============================================================================
# DATA STRUCTURES
# =============================================================================

@dataclass
class EpicycleState:
    """State of a single epicycle."""
    order: int
    radius: float
    angular_velocity: float
    phase: float
    resonance_strength: float
    phi_coupling: float


@dataclass
class TrajectoryPoint:
    """Single point in a trajectory."""
    time: float
    x: float
    y: float
    momentum: float
    godhood_factor: float
    phase_name: str


# =============================================================================
# CORE EPICYCLE MATH
# =============================================================================

def create_epicycle_states(coords: Tuple[int, int, int]) -> List[EpicycleState]:
    """
    Create epicycle states for given coordinates.

    Each coordinate component influences different epicycle orders.
    """
    x, y, z = coords
    states = []

    # Distance from center
    center = MATRIX_SIZE // 2
    dx, dy, dz = x - center, y - center, z - center
    r = math.sqrt(dx*dx + dy*dy + dz*dz)

    # Phase from position
    if r > 0:
        base_phase = math.atan2(dy, dx)
    else:
        base_phase = 0.0

    # K11 level
    k11_level = ((x + y + z) % 23) - 11

    for i, order in enumerate(EPICYCLE_ORDERS[:min(7, len(EPICYCLE_ORDERS))]):
        # Radius decreases with order (1/order * phi^i)
        radius = r / (order * (PHI ** (i * 0.5)))

        # Angular velocity increases with order
        angular_velocity = PHI * order / (r + 1)

        # Phase depends on order and position
        phase = (base_phase + i * math.pi / PHI) % (2 * math.pi)

        # Resonance strength based on phi-harmonics
        resonance_strength = 1.0 / (1 + abs(order - PHI ** round(math.log(order + 1) / math.log(PHI))))

        # Phi coupling
        phi_coupling = K5 * resonance_strength / (1 + i * 0.1)

        states.append(EpicycleState(
            order=order,
            radius=radius,
            angular_velocity=angular_velocity,
            phase=phase,
            resonance_strength=resonance_strength,
            phi_coupling=phi_coupling
        ))

    return states


# =============================================================================
# CONTENT-AWARE EPICYCLE PHYSICS
# =============================================================================

def create_content_epicycle(content_mass: float, energy: float,
                            transmission_ratio: float,
                            coords: Tuple[int, int, int],
                            i_logic_state: str = "DIRECT") -> Dict[str, Any]:
    """
    Create epicycle physics from CONTENT properties.

    Content defines mass. Mass defines orbital behavior.
    The membrane T/R ratio modulates the epicycle radii —
    high transmission = tight orbit, high reflection = wide orbit.

    This connects the FML token (what the content IS) to the
    epicycle model (how the content moves through the swarm).

    Args:
        content_mass: energy × transmission × K11 (from mass shell)
        energy: FML L5 information entropy (0.0-1.0)
        transmission_ratio: membrane T ratio (0.0-1.0)
        coords: FML L3 Morton coordinates (x, y, z)
        i_logic_state: FML L4 state name

    Returns:
        Dict with epicycle states, resonance, trajectory summary,
        SRL time, and membrane action.
    """
    x, y, z = coords
    states = create_epicycle_states((x, y, z))
    resonance = calculate_resonance(states)

    # Content mass modulates epicycle behavior:
    # - Radius scales inversely with mass (heavier = tighter orbit)
    # - Angular velocity scales with √mass (Kepler: v ∝ √(M/r))
    # - Transmission ratio dampens reflection epicycles
    mass_factor = content_mass / (K11 + 0.001) if content_mass > 0 else 0.0

    # SRL time from content depth
    depth = max(1, int(energy * 25))
    srl_time = int(math.sqrt(depth))

    # Phase from I-Logic state (matches swarm.srl_t logic)
    state_phases = {
        "DIRECT": 0.0,
        "SPIRAL": math.pi / 2,
        "INVERSE": math.pi,
        "ANTI_SPIRAL": -math.pi / 2,
        "ABSORBED": 0.0,
    }
    phase_offset = state_phases.get(i_logic_state, 0.0)

    # Effective orbital parameters
    if content_mass > 1e-6:
        # G_CST = K11 / (PHI * 131)
        G_CST = K11 / (PHI * 131)
        orbital_period = 2 * math.pi * math.sqrt(1.0 / (G_CST * content_mass))
        orbital_velocity = math.sqrt(G_CST * content_mass)
        escape_velocity = math.sqrt(2 * G_CST * content_mass)
    else:
        orbital_period = float('inf')
        orbital_velocity = 0.0
        escape_velocity = 0.0

    # Membrane modulation: T ratio dampens the outer epicycles
    # High T = energy passes through = tight orbit = less outer harmonics
    # High R = energy reflects = wide orbit = more outer harmonics
    modulated_resonance = resonance["total_resonance"] * (1.0 - transmission_ratio * 0.3)

    return {
        "content_mass": round(content_mass, 6),
        "mass_factor": round(mass_factor, 4),
        "energy": round(energy, 4),
        "transmission_ratio": round(transmission_ratio, 4),
        "coords": coords,
        "i_logic_state": i_logic_state,
        "phase_offset": round(phase_offset, 4),
        "orbital": {
            "period": round(orbital_period, 4) if orbital_period != float('inf') else "INF",
            "velocity": round(orbital_velocity, 6),
            "escape_velocity": round(escape_velocity, 6),
        },
        "resonance": {
            "base": round(resonance["total_resonance"], 6),
            "modulated": round(modulated_resonance, 6),
            "phi_coupling": round(resonance["phi_coupling"], 6),
            "stability": round(resonance["stability"], 6),
        },
        "srl": {
            "depth": depth,
            "time": srl_time,
            "compression": f"{depth} → {srl_time}",
        },
        "membrane_action": "TRANSMIT" if transmission_ratio > 0.5 else "REFLECT",
        "physics_interpretation": (
            f"Content mass {content_mass:.3f} at {i_logic_state} phase: "
            f"{'tight' if mass_factor > 0.5 else 'wide'} orbit, "
            f"T={orbital_period:.1f}, v_esc={escape_velocity:.4f}"
            if content_mass > 1e-6
            else f"Zero mass at C=0: no orbit, REFLECT at membrane"
        ),
    }


def calculate_position_at_time(states: List[EpicycleState], t: float) -> Tuple[float, float]:
    """Calculate x, y position from all epicycles at time t."""
    x = y = 0.0

    for state in states:
        angle = state.phase + state.angular_velocity * t
        x += state.radius * math.cos(angle)
        y += state.radius * math.sin(angle)

    return x, y


def generate_trajectory(
    states: List[EpicycleState],
    time_range: Tuple[float, float] = (0, 10),
    steps: int = 50
) -> List[TrajectoryPoint]:
    """Generate trajectory points over time range."""
    t_start, t_end = time_range
    dt = (t_end - t_start) / steps

    trajectory = []

    for i in range(steps):
        t = t_start + i * dt
        x, y = calculate_position_at_time(states, t)

        # Momentum (velocity magnitude)
        if i > 0:
            prev_x, prev_y = calculate_position_at_time(states, t - dt)
            momentum = math.sqrt((x - prev_x)**2 + (y - prev_y)**2) / dt
        else:
            momentum = 0.0

        # Godhood factor (resonance with phi)
        r = math.sqrt(x*x + y*y)
        godhood = 1.0 / (1 + abs(r - PHI ** round(math.log(r + 1) / math.log(PHI))))

        # Phase name
        phase_rad = math.atan2(y, x)
        phase_deg = math.degrees(phase_rad) % 360
        if phase_deg < 90:
            phase_name = "DIRECT"
        elif phase_deg < 180:
            phase_name = "SPIRAL"
        elif phase_deg < 270:
            phase_name = "INVERSE"
        else:
            phase_name = "CONVERGENT"

        trajectory.append(TrajectoryPoint(
            time=t,
            x=x,
            y=y,
            momentum=momentum,
            godhood_factor=godhood,
            phase_name=phase_name
        ))

    return trajectory


def calculate_resonance(states: List[EpicycleState]) -> Dict[str, float]:
    """Calculate overall resonance metrics from epicycle states."""
    total_resonance = sum(s.resonance_strength for s in states)
    phi_coupling = sum(s.phi_coupling for s in states)

    # Frequency spread
    velocities = [s.angular_velocity for s in states]
    if len(velocities) > 1:
        freq_spread = max(velocities) - min(velocities)
    else:
        freq_spread = 0.0

    # Phase coherence
    phases = [s.phase for s in states]
    if len(phases) > 1:
        phase_diff = sum(abs(phases[i] - phases[i-1]) for i in range(1, len(phases)))
        phase_coherence = 1.0 / (1 + phase_diff / math.pi)
    else:
        phase_coherence = 1.0

    # Stability
    stability = total_resonance * phase_coherence / (freq_spread + 1)

    return {
        "total_resonance": total_resonance,
        "phi_coupling": phi_coupling,
        "frequency_spread": freq_spread,
        "phase_coherence": phase_coherence,
        "stability": stability
    }


# =============================================================================
# K11 MAPPING
# =============================================================================

def k11_epicycle_mapping(coords: Tuple[int, int, int]) -> Dict[str, Any]:
    """Map coordinates to K11 epicycle structure."""
    x, y, z = coords

    # K11 level from position
    morton_proxy = x + y * 48 + z * 48 * 48
    k11_level = (morton_proxy % 23) - 11

    # I-Logic state
    if k11_level == 0:
        i_state = "ABSORBED"
    elif k11_level > 0:
        i_state = "DIRECT" if k11_level % 2 == 1 else "SPIRAL"
    else:
        i_state = "INVERSE" if abs(k11_level) % 2 == 1 else "CONVERGENT"

    # Ptolemaic mapping (classical orbital model)
    center = MATRIX_SIZE // 2
    dx, dy, dz = x - center, y - center, z - center
    r = math.sqrt(dx*dx + dy*dy)

    # Earth observer (from center)
    earth_observer = (center, center, center)

    # Prime mover (outermost sphere)
    prime_mover_distance = MATRIX_SIZE * PHI / 2

    # Retrograde motion (based on K11 polarity)
    retrograde_motion = k11_level < 0

    # Equant point (offset from center for non-uniform motion)
    equant_offset = r * 0.1 * k11_level / 11
    equant_point = (center + equant_offset, center, center)

    return {
        "coords": coords,
        "k11_level": k11_level,
        "i_state": i_state,
        "ptolemaic": {
            "earth_observer": earth_observer,
            "prime_mover_distance": round(prime_mover_distance, 4),
            "retrograde_motion": retrograde_motion,
            "equant_point": tuple(round(e, 2) for e in equant_point)
        },
        "orbital_radius": round(r, 4),
        "k11_velocity": K11_VELOCITIES[abs(k11_level) % len(K11_VELOCITIES)]
    }


# =============================================================================
# GODHOOD SPHERE
# =============================================================================

@dataclass
class SphereSection:
    """A section of the godhood sphere."""
    section_id: int
    name: str
    projection_type: str
    godhood_intensity: float
    center_phi: float
    center_theta: float


def create_godhood_sphere(num_sections: int = 12) -> Dict[str, Any]:
    """Create mathematical godhood sphere."""
    sections = []

    projection_types = [
        "STEREOGRAPHIC",
        "MERCATOR",
        "AZIMUTHAL",
        "GNOMONIC",
        "ORTHOGRAPHIC",
        "LAMBERT"
    ]

    section_names = [
        "GENESIS", "LOGOS", "SOPHIA", "NOUS",
        "PSYCHE", "PNEUMA", "AETHER", "PHYSIS",
        "CHRONOS", "KAIROS", "TELOS", "ARCHE"
    ]

    for i in range(num_sections):
        phi = (i * 2 * math.pi / num_sections) % (2 * math.pi)
        theta = math.pi / 2 * math.sin(phi * PHI)

        # Godhood intensity based on phi-resonance
        godhood = (1 + math.cos(phi - math.pi / PHI)) / 2

        sections.append(SphereSection(
            section_id=i,
            name=section_names[i % len(section_names)],
            projection_type=projection_types[i % len(projection_types)],
            godhood_intensity=godhood,
            center_phi=phi,
            center_theta=theta
        ))

    total_godhood = sum(s.godhood_intensity for s in sections)

    return {
        "radius": PHI * K11,
        "sections": sections,
        "total_godhood": total_godhood
    }


# =============================================================================
# SHELL OPERATIONS
# =============================================================================

def get_system_status() -> Dict[str, Any]:
    """Get epicycle shell system status."""
    return {
        "shell": "epicycle_shell",
        "version": "1.0.0",
        "hex_id": "E7C50000",
        "status": "ACTIVE",
        "constants": {
            "PHI": PHI,
            "K5": K5,
            "K11": K11,
            "BASE_FREQUENCY": BASE_FREQUENCY,
            "LIGHT_UNIT": LIGHT_UNIT
        },
        "epicycle_orders": EPICYCLE_ORDERS,
        "k11_velocities_count": len(K11_VELOCITIES),
        "matrix_size": MATRIX_SIZE,
        "total_cells": MATRIX_SIZE ** 3,
        "subsystems": {
            "core_math": "operational",
            "orbital_dynamics": "operational",
            "k11_mapper": "operational",
            "resonance_patterns": "operational",
            "godhood_sphere": "operational"
        },
        "timestamp": datetime.now().isoformat()
    }


# =============================================================================
# SHELL CLASS
# =============================================================================

class EpicycleShell:
    """Epicycle Shell - Comprehensive Epicycle Operations."""

    def __init__(self):
        self.name = "epicycle"
        self.hex_id = "E7C50000"
        self.version = "1.0.0"

    def status(self) -> Dict[str, Any]:
        """Get epicycle system status."""
        return get_system_status()

    def create(self, x: int, y: int, z: int) -> Dict[str, Any]:
        """Create epicycles for coordinates."""
        states = create_epicycle_states((x, y, z))

        return {
            "coords": (x, y, z),
            "epicycles": [
                {
                    "order": s.order,
                    "radius": round(s.radius, 6),
                    "angular_velocity": round(s.angular_velocity, 6),
                    "phase": round(s.phase, 6),
                    "resonance_strength": round(s.resonance_strength, 6),
                    "phi_coupling": round(s.phi_coupling, 6)
                }
                for s in states
            ],
            "total_resonance": sum(s.resonance_strength for s in states),
            "computed_at": datetime.now().isoformat()
        }

    def trajectory(self, x: int, y: int, z: int, steps: int = 50,
                   time_range: Tuple[float, float] = (0, 10)) -> Dict[str, Any]:
        """Calculate orbital trajectory."""
        states = create_epicycle_states((x, y, z))
        traj = generate_trajectory(states, time_range, steps)

        return {
            "coords": (x, y, z),
            "time_range": time_range,
            "steps": steps,
            "trajectory_summary": {
                "total_points": len(traj),
                "start_position": (round(traj[0].x, 4), round(traj[0].y, 4)),
                "end_position": (round(traj[-1].x, 4), round(traj[-1].y, 4)),
                "max_godhood": round(max(p.godhood_factor for p in traj), 4),
                "max_momentum": round(max(p.momentum for p in traj), 4)
            },
            "sample_points": [
                {
                    "time": round(p.time, 3),
                    "x": round(p.x, 4),
                    "y": round(p.y, 4),
                    "momentum": round(p.momentum, 4),
                    "godhood": round(p.godhood_factor, 4),
                    "phase": p.phase_name
                }
                for p in traj[::max(1, len(traj)//10)]
            ],
            "computed_at": datetime.now().isoformat()
        }

    def resonance(self, x: int, y: int, z: int) -> Dict[str, Any]:
        """Calculate resonance metrics."""
        states = create_epicycle_states((x, y, z))
        res = calculate_resonance(states)

        return {
            "coords": (x, y, z),
            "resonance": {
                "total_resonance": round(res["total_resonance"], 6),
                "phi_coupling": round(res["phi_coupling"], 6),
                "frequency_spread": round(res["frequency_spread"], 6),
                "phase_coherence": round(res["phase_coherence"], 6),
                "stability": round(res["stability"], 6)
            },
            "computed_at": datetime.now().isoformat()
        }

    def k11_map(self, x: int, y: int, z: int) -> Dict[str, Any]:
        """K11 epicycle mapping."""
        mapping = k11_epicycle_mapping((x, y, z))
        mapping["computed_at"] = datetime.now().isoformat()
        return mapping

    def godhood_sphere(self, sections: int = 12) -> Dict[str, Any]:
        """Create godhood sphere."""
        sphere = create_godhood_sphere(sections)

        return {
            "godhood_sphere": {
                "radius": sphere["radius"],
                "sections": sections,
                "total_godhood": round(sphere["total_godhood"], 3)
            },
            "sections": [
                {
                    "id": s.section_id,
                    "name": s.name,
                    "projection": s.projection_type,
                    "godhood": round(s.godhood_intensity, 3),
                    "phi": round(s.center_phi, 4),
                    "theta": round(s.center_theta, 4)
                }
                for s in sphere["sections"]
            ],
            "computed_at": datetime.now().isoformat()
        }

    def content_orbit(self, content_mass: float, energy: float,
                      transmission_ratio: float,
                      x: int, y: int, z: int,
                      i_logic_state: str = "DIRECT") -> Dict[str, Any]:
        """Create epicycle physics from content properties.

        Content defines mass. Mass defines orbital behavior.
        The membrane T/R ratio modulates epicycle radii.
        High T = tight orbit (heavy content passes through).
        High R = wide orbit (light content reflects back).
        """
        result = create_content_epicycle(
            content_mass, energy, transmission_ratio,
            (x, y, z), i_logic_state
        )
        result["computed_at"] = datetime.now().isoformat()
        return result

    def execute(self, command: str, args: Dict[str, Any] = None) -> Dict[str, Any]:
        """Execute shell command."""
        args = args or {}

        if command == "status":
            return self.status()
        elif command == "create":
            return self.create(
                args.get("x", 24),
                args.get("y", 24),
                args.get("z", 24)
            )
        elif command == "trajectory":
            return self.trajectory(
                args.get("x", 24),
                args.get("y", 24),
                args.get("z", 24),
                args.get("steps", 50)
            )
        elif command == "resonance":
            return self.resonance(
                args.get("x", 24),
                args.get("y", 24),
                args.get("z", 24)
            )
        elif command == "k11-map":
            return self.k11_map(
                args.get("x", 24),
                args.get("y", 24),
                args.get("z", 24)
            )
        elif command == "godhood-sphere":
            return self.godhood_sphere(args.get("sections", 12))
        elif command == "content_orbit":
            return self.content_orbit(
                args.get("content_mass", 4.6),
                args.get("energy", 0.5),
                args.get("transmission_ratio", 0.5),
                args.get("x", 24),
                args.get("y", 24),
                args.get("z", 24),
                args.get("i_logic_state", "DIRECT")
            )
        else:
            return {"error": f"Unknown command: {command}"}

    def run(self, command: str, *args, as_json: bool = False) -> Any:
        """Run a shell command (CLI interface)."""
        commands = {
            'status': lambda: self.status(),
            'create': lambda: self.create(int(args[0]) if len(args) > 0 else 24,
                                           int(args[1]) if len(args) > 1 else 24,
                                           int(args[2]) if len(args) > 2 else 24),
            'trajectory': lambda: self.trajectory(int(args[0]) if len(args) > 0 else 24,
                                                   int(args[1]) if len(args) > 1 else 24,
                                                   int(args[2]) if len(args) > 2 else 24,
                                                   int(args[3]) if len(args) > 3 else 50),
            'resonance': lambda: self.resonance(int(args[0]) if len(args) > 0 else 24,
                                                 int(args[1]) if len(args) > 1 else 24,
                                                 int(args[2]) if len(args) > 2 else 24),
            'k11-map': lambda: self.k11_map(int(args[0]) if len(args) > 0 else 24,
                                             int(args[1]) if len(args) > 1 else 24,
                                             int(args[2]) if len(args) > 2 else 24),
            'godhood-sphere': lambda: self.godhood_sphere(int(args[0]) if args else 12),
            'content_orbit': lambda: self.content_orbit(
                float(args[0]) if len(args) > 0 else 4.6,
                float(args[1]) if len(args) > 1 else 0.5,
                float(args[2]) if len(args) > 2 else 0.5,
                int(args[3]) if len(args) > 3 else 24,
                int(args[4]) if len(args) > 4 else 24,
                int(args[5]) if len(args) > 5 else 24,
                args[6] if len(args) > 6 else "DIRECT"
            ),
        }
        if command in commands:
            result = commands[command]()
            if as_json and isinstance(result, dict):
                return json.dumps(result, indent=2, default=str)
            return result
        return {'error': f'Unknown command: {command}', 'available': list(commands.keys())}


# =============================================================================
# CLI INTERFACE
# =============================================================================

def main():
    parser = argparse.ArgumentParser(
        description='Epicycle Shell - Comprehensive Epicycle Operations',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    python -m cubesquare.shells.epicycle --status
    python -m cubesquare.shells.epicycle --create 43 10 9
    python -m cubesquare.shells.epicycle --trajectory 43 10 9 --steps 100
    python -m cubesquare.shells.epicycle --resonance 43 10 9
    python -m cubesquare.shells.epicycle --k11-map 43 10 9
    python -m cubesquare.shells.epicycle --godhood-sphere --sections 12

Epicycle orders follow Fibonacci: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144
"""
    )

    parser.add_argument('--status', action='store_true', help='Epicycle system status')
    parser.add_argument('--create', nargs=3, type=int, metavar=('X', 'Y', 'Z'),
                       help='Create epicycles for coordinates')
    parser.add_argument('--trajectory', nargs=3, type=int, metavar=('X', 'Y', 'Z'),
                       help='Calculate trajectory')
    parser.add_argument('--steps', type=int, default=50, help='Trajectory steps (default: 50)')
    parser.add_argument('--resonance', nargs=3, type=int, metavar=('X', 'Y', 'Z'),
                       help='Calculate resonance')
    parser.add_argument('--k11-map', nargs=3, type=int, metavar=('X', 'Y', 'Z'),
                       help='K11 epicycle mapping')
    parser.add_argument('--godhood-sphere', action='store_true', help='Create godhood sphere')
    parser.add_argument('--sections', type=int, default=12, help='Sphere sections (default: 12)')
    parser.add_argument('--json', action='store_true', help='JSON output')

    args = parser.parse_args()

    shell = EpicycleShell()
    result = None

    if args.status:
        result = shell.status()
    elif args.create:
        result = shell.create(*args.create)
    elif args.trajectory:
        result = shell.trajectory(*args.trajectory, steps=args.steps)
    elif args.resonance:
        result = shell.resonance(*args.resonance)
    elif args.k11_map:
        result = shell.k11_map(*args.k11_map)
    elif args.godhood_sphere:
        result = shell.godhood_sphere(args.sections)
    else:
        parser.print_help()
        return

    if result:
        print(json.dumps(result, indent=2, default=str))


if __name__ == '__main__':
    main()
