"""
How implicit physics modelling and explicit 4D Gaussian output fit together.
"""
from dataclasses import dataclass, field
from enum import Enum


class PhysicsKind(Enum):
    GRAVITY = "gravity"
    ELASTICITY = "elasticity"
    BUOYANCY = "buoyancy"
    LIGHTING = "lighting"
    SOFT_BODY = "soft_body"
    FLUID = "fluid"
    RIGID_BODY = "rigid_body"
    DEFORMABLE = "deformable"
    THERMAL = "thermal"


@dataclass
class SceneConditioning:
    """What the model must be told before it can simulate anything."""
    prompt: str
    initial_4d_state: dict = field(default_factory=dict)
    horizon_frames: int = 2000
    active_physics: list[PhysicsKind] = field(default_factory=list)


@dataclass
class FourDGaussianAsset:
    """
    The delivered artifact: explicit, renderable, reusable.

    Each Gaussian carries position, orientation, scale, opacity, colour,
    AND a time component -- that extra t is what makes it 4D rather than 3D.
    """
    positions: list[tuple[float, float, float]]
    scales: list[tuple[float, float, float]]
    rotations: list[tuple[float, float, float, float]]
    opacities: list[float]
    sh_coeffs: list[list[float]]
    timestamps: list[float]          # the 4th dimension

    def frame_count(self) -> int:
        return len(set(self.timestamps))

    def supports_realtime_render(self, target_fps: int = 70) -> bool:
        # Measured: 500+ fps for 3D/4D gaussian asset rendering,
        # ~100 fps on phone. So yes, comfortably.
        return True


def build_scene(prompt: str, kinds: list[PhysicsKind]) -> SceneConditioning:
    return SceneConditioning(
        prompt=prompt,
        horizon_frames=2000,
        active_physics=kinds,
    )


def bookmark_demo() -> SceneConditioning:
    """
    The live demo: breeze turns pages, a bookmark slips out and falls.
    Five coupled physics effects in one shot.
    """
    return build_scene(
        prompt="breeze turns the pages of a book; a bookmark slips out and falls "
               "to the floor; pages flex under the wind, bookmark lands and settles",
        kinds=[
            PhysicsKind.GRAVITY,      # bookmark falls
            PhysicsKind.SOFT_BODY,    # pages bend
            PhysicsKind.RIGID_BODY,   # floor is rigid
            PhysicsKind.LIGHTING,     # light shifts as pages move
            PhysicsKind.DEFORMABLE,   # contact + separation at the page edge
        ],
    )


if __name__ == "__main__":
    scene = bookmark_demo()
    print(f"prompt      : {scene.prompt[:60]}...")
    print(f"horizon     : {scene.horizon_frames} frames")
    print(f"physics     : {[k.value for k in scene.active_physics]}")
    print(f"coupled     : {len(scene.active_physics)} simultaneous effects")
    print("if any one is wrong, the eye catches it immediately")

"""
Why a 70% cost reduction matters more than it sounds.
"""
def inference_economics(requests_per_day: int = 100_000,
                        gpu_cost_per_1k: float = 1.00,
                        ascend_ratio: float = 0.30):
    """
    Same workload, two hardware baselines.
    """
    gpu_total = requests_per_day / 1000 * gpu_cost_per_1k
    ascend_total = gpu_total * ascend_ratio

    saved = gpu_total - ascend_total
    capacity_multiple = 1 / ascend_ratio

    print(f"{'Metric':<32}{'Value'}")
    print("-" * 52)
    print(f"{'daily requests':<32}{requests_per_day:,}")
    print(f"{'GPU baseline cost':<32}${gpu_total:,.2f}")
    print(f"{'Ascend-native cost (30%)':<32}${ascend_total:,.2f}")
    print(f"{'daily saving':<32}${saved:,.2f}")
    print(f"{'annual saving':<32}${saved * 365:,.2f}")
    print(f"{'same budget serves':<32}{capacity_multiple:.1f}x the traffic")
    print()
    print("The interesting number is not the saving. It is the capacity multiple:")
    print("a world model that renders in realtime only becomes a product")
    print("when the marginal cost of one more rendered minute is near zero.")


inference_economics()

"""
Generation fps vs rendering fps: two completely different budgets.
"""
def frame_budget(fps: int) -> dict:
    budget_ms = 1000 / fps
    return {
        "fps": fps,
        "budget_ms": round(budget_ms, 2),
        "what runs": None,
    }


def compare_pipelines():
    rows = [
        ("video inference (gen)", 50, "neural net forward pass, per frame", "before"),
        ("video inference (gen)", 70, "neural net forward pass, per frame", "after"),
        ("4D gaussian render", 500, "rasterisation only, no NN", "asset playback"),
        ("phone-side render", 100, "rasterisation on Kirin NPU/GPU", "asset playback"),
    ]

    print(f"{'Stage':<26}{'fps':<8}{'budget':<12}{'what runs'}")
    print("-" * 92)
    for name, fps, what, _ in rows:
        b = frame_budget(fps)
        print(f"{name:<26}{fps:<8}{str(b['budget_ms']) + ' ms':<12}{what}")

    gen_before = 1000 / 50
    gen_after = 1000 / 70
    print()
    print(f"generation budget: {gen_before:.1f} ms -> {gen_after:.1f} ms "
          f"({(gen_before - gen_after) / gen_before:.0%} tighter)")
    print(f"render is {500 / 70:.1f}x faster than generation because it skips the NN")
    print()
    print("Design implication: put generation in the cloud, put rendering on the device.")


compare_pipelines()

"""
End-to-end chain: a few phone photos -> a 4D pet companion.
"""
from dataclasses import dataclass


@dataclass
class PetPhotos:
    count: int
    resolution: str
    angles: list[str]


@dataclass
class CloudStage:
    """Runs on Ascend. Heavy, asynchronous, tolerant of latency."""
    model: str = "MoWorld 2.0 (KOKONI-World 14B class)"
    task: str = "reconstruct + generate high-quality 4D gaussian asset"
    output: str = "4D gaussian asset (positions, scales, rotations, "
    output: str = "opacity, SH coeffs, per-frame timestamps"
    latency_tolerance: str = "seconds to minutes -- user is waiting, not staring"


@dataclass
class DeviceStage:
    """Runs on Kirin. Light, synchronous, latency-critical."""
    model: str = "MoWorld 2.0 edge variant, ~0.6B params"
    task: str = "render + respond to touch/interaction"
    target_fps: int = 100
    budget_ms_per_frame: float = 10.0


def pipeline(photos: PetPhotos) -> dict:
    cloud = CloudStage()
    device = DeviceStage()

    # Why the split works: the two stages have inverted cost profiles.
    return {
        "input": f"{photos.count} photos @ {photos.resolution}",
        "cloud": {
            "model": cloud.model,
            "runs": "Ascend",
            "does": cloud.task,
            "tolerance": cloud.latency_tolerance,
        },
        "device": {
            "model": cloud.model and device.model,
            "runs": "Kirin",
            "does": device.task,
            "fps": device.target_fps,
            "budget_ms": device.budget_ms_per_frame,
        },
        "why_it_works": [
            "cloud carries the 14B model -> quality stays high",
            "device carries 0.6B + rasterisation -> latency stays low",
            "asset is explicit (4D gaussian) -> no NN needed at playback",
            "only new asset generation needs the network",
        ],
    }


if __name__ == "__main__":
    out = pipeline(PetPhotos(count=5, resolution="12MP", angles=["front", "side", "top"]))
    for k, v in out.items():
        print(f"{k}: {v}")

"""
Why reusable assets change the business model from linear to near-zero marginal cost.
"""
def cost_structure(scenes: int, renders_per_scene: int,
                   gen_cost: float = 1.0, render_cost: float = 0.002):
    """
    Compare: regenerate-on-demand vs generate-once-then-reuse.
    """
    regenerate = scenes * renders_per_scene * (gen_cost + render_cost)
    reuse = scenes * gen_cost + scenes * renders_per_scene * render_cost

    print(f"{'Model':<34}{'Total cost':<16}{'Per render'}")
    print("-" * 66)
    print(f"{'regenerate each time':<34}${regenerate:,.2f}"
          f"{'':<8}${regenerate / (scenes * renders_per_scene):,.4f}")
    print(f"{'generate once, reuse':<34}${reuse:,.2f}"
          f"{'':<8}${reuse / (scenes * renders_per_scene):,.4f}")
    print(f"\nsaving: {(1 - reuse / regenerate):.1%}")
    print(f"marginal cost of the Nth render: ${render_cost:.4f} (flat)")
    print()
    print("This is why the asset matters more than the model:")
    print("a model is a service you rent; an asset is inventory you own.")


cost_structure(scenes=100, renders_per_scene=1000)

"""
Reading the cap table as a supply-chain map, not a list of investors.
"""
def investor_structure():
    sectors = {
        "chips":        "silicon that the model must run on",
        "compute":      "clusters that train the 14B model",
        "smart devices": "phones / headsets that render the 4D assets",
        "content platforms": "who buys rendered scenes and assets",
        "advanced manufacturing": "factories / production lines to digitise",
    }
    state_funds = ["Shenzhen Capital Group (深创投)", "Zhejiang Venture Capital (浙创投)"]

    print("Industry capital, by the bottleneck it unlocks:")
    for sector, why in sectors.items():
        print(f"  {sector:<22} -> {why}")

    print("\nState-backed funds:", ", ".join(state_funds))
    print("\nRounds in 2026: 5")
    print("Total raised:    2.0B CNY (~$280M)")
    print("Valuation:       ~10B CNY (~$1.4B)")
    print("Next round:      launched, possibly ~1B CNY")
    print()
    print("Note the pattern: five rounds in one year is not a growth story,")
    print("it is a land-grab -- the window for 'national compute + world model'")
    print("is being priced as if it closes soon.")


investor_structure()