from dataclasses import dataclass
from IPython.display import SVG, display
import math

@dataclass
class Shape:
    verts: list
    def edge(self, i, j=None):
        if j is None: j = (i + 1) % len(self.verts)
        return self.verts[i], self.verts[j]
    def flap(self, i, j=None, depth=15, taper=0.7):
        a, b = self.edge(i, j)
        return flap_svg(a, b, depth, taper)

def grow_triangle(edge, flip=False):
    a, b = edge
    c = third_vertex(a, b, flip)
    return Shape([a, b, c])

def grow_pentagon(edge, side, flip=False):
    cx, cy, rot = pentagon_from_edge(edge[0], edge[1], side, flip)
    return Shape(pentagon_verts(cx, cy, rot, side))

def grow_square(edge, flip=False):
    a, b = edge
    dx, dy = b[0]-a[0], b[1]-a[1]
    sign = -1 if flip else 1
    c, d = (b[0] + sign*(-dy), b[1] + sign*dx), (a[0] + sign*(-dy), a[1] + sign*dx)
    return Shape([a, b, c, d])
 
def pentagon_verts(cx, cy, rot, side):
    "Return 5 vertices of regular pentagon centered at (cx,cy) with given side length"
    R = side / (2 * math.sin(math.radians(36)))
    return [(cx + R*math.cos(math.radians(72*i + rot)), cy + R*math.sin(math.radians(72*i + rot))) for i in range(5)]

def pentagon_from_edge(p1, p2, side, flip=False):
    "Return center and rotation for pentagon sharing edge p1-p2"
    mx, my = (p1[0]+p2[0])/2, (p1[1]+p2[1])/2
    dx, dy = p2[0]-p1[0], p2[1]-p1[1]
    length = math.sqrt(dx*dx + dy*dy)
    px, py = -dy/length, dx/length
    apothem = side / (2 * math.tan(math.radians(36)))
    sign = -1 if flip else 1
    cx, cy = mx + sign*px*apothem, my + sign*py*apothem
    rot = math.degrees(math.atan2(dy, dx)) + 90 + (180 if flip else 0)
    return cx, cy, rot

def flap_svg(a, b, depth=15, taper=0.7, stroke="black", fill="none", sw=2):
    "Trapezoid flap attached to edge a-b, pointing outward"
    dx, dy = b[0]-a[0], b[1]-a[1]
    length = math.sqrt(dx*dx + dy*dy)
    px, py = -dy/length, dx/length
    inset = (1-taper) * length / 2
    c = (b[0]+px*depth - dx/length*inset, b[1]+py*depth - dy/length*inset)
    d = (a[0]+px*depth + dx/length*inset, a[1]+py*depth + dy/length*inset)
    pts = f"{a[0]},{a[1]} {b[0]},{b[1]} {c[0]},{c[1]} {d[0]},{d[1]}"
    return f'<polygon points="{pts}" fill="{fill}" stroke="{stroke}" stroke-width="{sw}"/>'

def svg_bounds(pts_list, pad=20):
    all_pts = [p for pts in pts_list for p in pts]
    xs, ys = [p[0] for p in all_pts], [p[1] for p in all_pts]
    min_x, max_x, min_y, max_y = min(xs), max(xs), min(ys), max(ys)
    w, h = max_x - min_x + 2*pad, max_y - min_y + 2*pad
    ox, oy = -min_x + pad, -min_y + pad
    return w, h, ox, oy

def shape_svg(s, stroke="black", fill="none", sw=2):
    pts = " ".join(f"{p[0]},{p[1]}" for p in s.verts)
    return f'<polygon points="{pts}" fill="{fill}" stroke="{stroke}" stroke-width="{sw}"/>'

s0 = Shape(pentagon_verts(0, 0, -90, 80))
w, h, ox, oy = svg_bounds([s0.verts])
def offset(p): return (p[0]+ox, p[1]+oy)
s0_off = Shape([offset(p) for p in s0.verts])

svg = f'<svg width="{w}" height="{h}" xmlns="http://www.w3.org/2000/svg">{shape_svg(s0_off)}</svg>'
display(SVG(svg))

def label_svg(p, text, dx=0, dy=-8, size=12):
    return f'<text x="{p[0]+dx}" y="{p[1]+dy}" font-size="{size}" text-anchor="middle">{text}</text>'

from pathlib import Path

def save_svg(svg, path): Path(path).write_text(svg)

save_svg(svg, 'triangle.svg')

import math

def third_vertex(a, b, flip=False):
    """Given edge (a,b), return third vertex of equilateral triangle
    using Pythagorean theorem says: (s/2)² + h² = s²
    we can derive h  = s × √3 / 2
    """
    mx, my = (a[0]+b[0])/2, (a[1]+b[1])/2
    dx, dy = b[0]-a[0], b[1]-a[1]
    h = math.sqrt(3)/2 * math.sqrt(dx*dx + dy*dy)
    px, py = -dy, dx
    length = math.sqrt(px*px + py*py)
    px, py = px/length, py/length
    sign = -1 if flip else 1
    return (mx + sign*px*h, my + sign*py*h)

a, b = (0, 0), (100, 0)
third_vertex(a, b), third_vertex(a, b, flip=True)

from dataclasses import dataclass, field
from typing import Literal

@dataclass
class NetBuilder:
    """Interactive builder for platonic solid nets"""
    shapes: list[Shape] = field(default_factory=list)
    flaps: list[str] = field(default_factory=list)
    side: float = 100
    flap_depth: float = 15
    flap_taper: float = 0.7
    
    def add_triangle(self, edge: tuple, flip: bool = False) -> int:
        """Grow a triangle from an edge. Returns shape index."""
        s = grow_triangle(edge, flip)
        self.shapes.append(s)
        return len(self.shapes) - 1
    
    def add_square(self, edge: tuple, flip: bool = False) -> int:
        """Grow a square from an edge. Returns shape index."""
        s = grow_square(edge, flip)
        self.shapes.append(s)
        return len(self.shapes) - 1
    
    def add_pentagon(self, edge: tuple, flip: bool = False) -> int:
        """Grow a pentagon from an edge. Returns shape index."""
        s = grow_pentagon(edge, self.side, flip)
        self.shapes.append(s)
        return len(self.shapes) - 1
    
    def start_triangle(self, flip: bool = False) -> int:
        """Start with a triangle at origin."""
        return self.add_triangle(((0, 0), (self.side, 0)), flip)
    
    def start_square(self, flip: bool = False) -> int:
        """Start with a square at origin."""
        return self.add_square(((0, 0), (self.side, 0)), flip)
    
    def start_pentagon(self, flip: bool = False) -> int:
        """Start with a pentagon at origin."""
        return self.add_pentagon(((0, 0), (self.side, 0)), flip)
    
    def grow(self, shape_idx: int, edge_start: int, edge_end: int = None, 
             shape_type: Literal['triangle', 'square', 'pentagon'] = 'triangle',
             flip: bool = False) -> int:
        """Grow a new shape from an edge of existing shape. Returns new shape index."""
        edge = self.shapes[shape_idx].edge(edge_start, edge_end)
        if shape_type == 'triangle':
            return self.add_triangle(edge, flip)
        elif shape_type == 'square':
            return self.add_square(edge, flip)
        else:
            return self.add_pentagon(edge, flip)
    
    def add_flap(self, shape_idx: int, edge_start: int, edge_end: int = None):
        """Add a glue flap to an edge."""
        # We'll compute this at render time using offset shapes
        self.flaps.append((shape_idx, edge_start, edge_end))
    
    def remove_shape(self, idx: int):
        """Remove a shape by index."""
        if 0 <= idx < len(self.shapes):
            self.shapes.pop(idx)
            # Adjust flap references
            self.flaps = [(s, e1, e2) for s, e1, e2 in self.flaps if s != idx]
            self.flaps = [(s-1 if s > idx else s, e1, e2) for s, e1, e2 in self.flaps]
    
    def remove_flap(self, idx: int):
        """Remove a flap by index."""
        if 0 <= idx < len(self.flaps):
            self.flaps.pop(idx)
    
    def clear_flaps(self):
        """Remove all flaps."""
        self.flaps = []
    
    def reset(self):
        """Clear everything."""
        self.shapes = []
        self.flaps = []
    
    def info(self) -> str:
        """Get current state info."""
        lines = [f"NetBuilder: {len(self.shapes)} shapes, {len(self.flaps)} flaps"]
        for i, s in enumerate(self.shapes):
            n = len(s.verts)
            kind = {3: 'triangle', 4: 'square', 5: 'pentagon'}.get(n, f'{n}-gon')
            lines.append(f"  [{i}] {kind} - edges: {list(range(n))}")
        if self.flaps:
            lines.append(f"  Flaps: {self.flaps}")
        return "\n".join(lines)
    
    def render(self, labels: bool = False, pad: float = 25) -> SVG:
        """Render current net as SVG."""
        if not self.shapes:
            return SVG('<svg width="100" height="50"><text x="10" y="30">Empty net</text></svg>')
        
        w, h, ox, oy = svg_bounds([s.verts for s in self.shapes], pad=pad)
        def offset(p): return (p[0]+ox, p[1]+oy)
        shapes_off = [Shape([offset(p) for p in s.verts]) for s in self.shapes]
        
        parts = [shape_svg(s) for s in shapes_off]
        
        # Add flaps
        for shape_idx, e1, e2 in self.flaps:
            if shape_idx < len(shapes_off):
                parts.append(shapes_off[shape_idx].flap(e1, e2, self.flap_depth, self.flap_taper))
        
        # Add labels if requested
        if labels:
            for i, s in enumerate(shapes_off):
                cx = sum(p[0] for p in s.verts) / len(s.verts)
                cy = sum(p[1] for p in s.verts) / len(s.verts)
                parts.append(f'<text x="{cx}" y="{cy}" font-size="14" text-anchor="middle" fill="blue">{i}</text>')
                for j, p in enumerate(s.verts):
                    # Offset label toward centroid (inside the angle)
                    dx, dy = cx - p[0], cy - p[1]
                    dist = math.sqrt(dx*dx + dy*dy)
                    offset_dist = 15
                    lx = p[0] + dx/dist * offset_dist
                    ly = p[1] + dy/dist * offset_dist
                    parts.append(f'<text x="{lx}" y="{ly}" font-size="10" text-anchor="middle" dominant-baseline="middle" fill="red">{j}</text>')

        
        svg = f'<svg width="{w}" height="{h}" xmlns="http://www.w3.org/2000/svg">{"".join(parts)}</svg>'
        return SVG(svg)
    
    def show(self, labels: bool = False):
        """Display the current net."""
        display(self.render(labels))

# Quick test
net = NetBuilder()
net.start_triangle()
net.grow(0, 1, 2, flip=True)
net.show(labels=True)
print(net.info())

from typing import Literal

# Global state for the net builder
_net = NetBuilder()

def net_reset() -> str:
    """Reset the net builder, clearing all shapes and flaps."""
    _net.reset()
    return "Net reset. Ready to start building."

def net_start(shape: Literal['triangle', 'square', 'pentagon'], flip: bool = False) -> str:
    """Start a new net with an initial shape at the origin.
    
    Args:
        shape: Type of shape - 'triangle', 'square', or 'pentagon'
        flip: If True, flip the shape orientation
    """
    _net.reset()
    if shape == 'triangle':
        idx = _net.start_triangle(flip)
    elif shape == 'square':
        idx = _net.start_square(flip)
    else:
        idx = _net.start_pentagon(flip)
    return f"Started with {shape} at index {idx}.\n{_net.info()}"

def net_grow(from_shape: int, edge_start: int, edge_end: int, 
             shape: Literal['triangle', 'square', 'pentagon'] = 'triangle',
             flip: bool = False) -> str:
    """Grow a new shape from an edge of an existing shape.
    
    Args:
        from_shape: Index of the shape to grow from
        edge_start: First vertex index of the edge
        edge_end: Second vertex index of the edge
        shape: Type of shape to grow
        flip: If True, flip the new shape orientation
    """
    try:
        idx = _net.grow(from_shape, edge_start, edge_end, shape, flip)
        return f"Added {shape} at index {idx}.\n{_net.info()}"
    except Exception as e:
        return f"Error: {e}\n{_net.info()}"

def net_add_flap(shape_idx: int, edge_start: int, edge_end: int) -> str:
    """Add a glue flap to an edge of a shape.
    
    Args:
        shape_idx: Index of the shape
        edge_start: First vertex index of the edge
        edge_end: Second vertex index of the edge
    """
    _net.add_flap(shape_idx, edge_start, edge_end)
    return f"Added flap to shape {shape_idx} edge ({edge_start},{edge_end}).\n{_net.info()}"

def net_remove_shape(idx: int) -> str:
    """Remove a shape by its index.
    
    Args:
        idx: Index of the shape to remove
    """
    _net.remove_shape(idx)
    return f"Removed shape {idx}.\n{_net.info()}"

def net_remove_flap(idx: int) -> str:
    """Remove a flap by its index in the flaps list.
    
    Args:
        idx: Index of the flap to remove
    """
    _net.remove_flap(idx)
    return f"Removed flap {idx}.\n{_net.info()}"

def net_clear_flaps() -> str:
    """Remove all flaps from the net."""
    _net.clear_flaps()
    return f"Cleared all flaps.\n{_net.info()}"

def net_info() -> str:
    """Get information about the current net state, including shape indices and edges."""
    return _net.info()

def net_show(labels: bool = True) -> str:
    """Display the current net as SVG. Blue numbers are shape indices, red are vertex indices.
    
    Args:
        labels: If True, show shape and vertex labels
    """
    _net.show(labels)
    return _net.info()

net_start('triangle', flip=False)
net_grow(0, 0, 2, 'triangle', flip=False)
net_grow(1, 2, 0, 'triangle', flip=True)
net_grow(2, 2, 0, 'triangle', flip=False)
net_add_flap(1, 2, 1)
net_add_flap(0, 1, 0)
net_add_flap(3, 0, 2)
net_show()

net_reset()
net_start('triangle')
net_grow(0, 0, 1, 'triangle', flip=True)
net_grow(0, 1, 2, 'triangle', flip=True)
net_grow(0, 2, 0, 'triangle', flip=True)
net_add_flap(1, 1, 2)
net_add_flap(2, 1, 2)
net_add_flap(3, 1, 2)
net_show()

net_reset()
net_start('square')
net_grow(0, 2, 3, 'square', flip=True)
net_grow(1, 2, 3, 'square', flip=True)
net_grow(2, 2, 3, 'square', flip=True)
net_grow(0, 1, 2, 'square', flip=True)
net_grow(0, 3, 0, 'square', flip=True)
net_add_flap(4, 0, 1)
net_add_flap(4, 1, 2)
net_add_flap(4, 2, 3)
net_add_flap(5, 0, 1)
net_add_flap(5, 2, 3)
net_add_flap(5, 3, 0)
net_add_flap(3, 1, 2)
net_add_flap(3, 2, 3)
net_add_flap(3, 3, 0)
net_show()