#!/usr/bin/env python3
"""
Sacred Banner of Peace Generator
Embeds mathematical beauty and sacred geometry into Roerich's Pax Cultura symbol
"""

import math
import xml.etree.ElementTree as ET
from datetime import datetime

# Sacred constants
PHI = (1 + math.sqrt(5)) / 2  # Golden ratio
PI = math.pi
TRINITY = 3
UNITY = 1

# Sacred angles
ANGLE_120 = 2 * PI / 3  # Trinity division of circle
ANGLE_60 = PI / 3       # Hexagonal harmony

class SacredBanner:
    def __init__(self, size=300):
        self.size = size
        self.center = size / 2
        
        # Sacred proportions based on golden ratio
        self.outer_radius = size * 0.4
        self.inner_radius = self.outer_radius / PHI
        
        # Protection circle (outer boundary)
        self.protection_radius = self.outer_radius * 1.1
        
    def calculate_trinity_centers(self):
        """Calculate centers of three inner circles using sacred geometry"""
        centers = []
        
        # Distance from center using sacred proportion
        distance = self.outer_radius * (2/3)  # 2/3 creates perfect harmony
        
        for i in range(TRINITY):
            # Start from top (12 o'clock) and rotate clockwise
            angle = -PI/2 + i * ANGLE_120
            x = self.center + distance * math.cos(angle)
            y = self.center + distance * math.sin(angle)
            centers.append((x, y))
            
        return centers
    
    def create_sacred_circle(self, cx, cy, r, fill="#D2393C", stroke="none", stroke_width=0):
        """Create a circle element with sacred attributes"""
        circle = ET.Element('circle')
        circle.set('cx', str(cx))
        circle.set('cy', str(cy))
        circle.set('r', str(r))
        circle.set('fill', fill)
        circle.set('stroke', stroke)
        circle.set('stroke-width', str(stroke_width))
        
        # Sacred data attributes
        circle.set('data-sacred', 'true')
        circle.set('data-phi', str(PHI))
        
        return circle
    
    def create_protection_sigil(self):
        """Create invisible protection sigil using sacred geometry"""
        sigil = ET.Element('g', id='protection-sigil')
        sigil.set('opacity', '0')  # Invisible but present
        
        # Create hexagram (Star of David) for protection
        points = []
        for i in range(6):
            angle = i * PI / 3
            x = self.center + self.protection_radius * math.cos(angle)
            y = self.center + self.protection_radius * math.sin(angle)
            points.append(f"{x},{y}")
        
        # First triangle
        triangle1 = ET.Element('polygon')
        triangle1.set('points', f"{points[0]} {points[2]} {points[4]}")
        triangle1.set('fill', 'none')
        triangle1.set('stroke', '#FFD700')  # Golden protection
        triangle1.set('stroke-width', '0.5')
        
        # Second triangle
        triangle2 = ET.Element('polygon')
        triangle2.set('points', f"{points[1]} {points[3]} {points[5]}")
        triangle2.set('fill', 'none')
        triangle2.set('stroke', '#FFD700')
        triangle2.set('stroke-width', '0.5')
        
        sigil.append(triangle1)
        sigil.append(triangle2)
        
        return sigil
    
    def generate_svg(self):
        """Generate the complete SVG with all sacred elements"""
        # Create SVG root
        svg = ET.Element('svg')
        svg.set('xmlns', 'http://www.w3.org/2000/svg')
        svg.set('width', str(self.size))
        svg.set('height', str(self.size))
        svg.set('viewBox', f'0 0 {self.size} {self.size}')
        
        # Add metadata
        metadata = ET.SubElement(svg, 'metadata')
        desc = ET.SubElement(metadata, 'desc')
        desc.text = f"Sacred Banner of Peace - Generated {datetime.now().isoformat()}"
        
        # Add title for accessibility
        title = ET.SubElement(svg, 'title')
        title.text = "Banner of Peace - Pax Cultura"
        
        # Create main group
        main_group = ET.SubElement(svg, 'g', id='banner-of-peace')
        
        # Add invisible protection sigil
        main_group.append(self.create_protection_sigil())
        
        # White background circle
        bg_circle = self.create_sacred_circle(
            self.center, self.center, self.outer_radius,
            fill="white", stroke="#D2393C", stroke_width=3
        )
        main_group.append(bg_circle)
        
        # Outer red circle (ring)
        outer_ring = self.create_sacred_circle(
            self.center, self.center, self.outer_radius,
            fill="none", stroke="#D2393C", stroke_width=self.outer_radius * 0.15
        )
        main_group.append(outer_ring)
        
        # Three inner circles (Trinity)
        trinity_centers = self.calculate_trinity_centers()
        for i, (cx, cy) in enumerate(trinity_centers):
            inner_circle = self.create_sacred_circle(cx, cy, self.inner_radius, fill="#D2393C")
            inner_circle.set('id', f'trinity-{i+1}')
            inner_circle.set('data-element', ['past', 'present', 'future'][i])
            main_group.append(inner_circle)
        
        # Add sacred geometry guide (invisible)
        sacred_guide = ET.SubElement(main_group, 'g', id='sacred-geometry')
        sacred_guide.set('opacity', '0')
        
        # Golden ratio spiral (for energy flow)
        spiral_path = self.create_golden_spiral()
        sacred_guide.append(spiral_path)
        
        return svg
    
    def create_golden_spiral(self):
        """Create a golden ratio spiral path"""
        path = ET.Element('path')
        
        # Simplified golden spiral using quadratic Bezier curves
        a = self.inner_radius
        commands = f"M {self.center} {self.center} "
        
        for i in range(4):
            angle = i * PI / 2
            r = a * (PHI ** (i * 0.5))
            x1 = self.center + r * math.cos(angle)
            y1 = self.center + r * math.sin(angle)
            x2 = self.center + r * math.cos(angle + PI/4)
            y2 = self.center + r * math.sin(angle + PI/4)
            commands += f"Q {x1} {y1} {x2} {y2} "
        
        path.set('d', commands)
        path.set('fill', 'none')
        path.set('stroke', '#FFD700')
        path.set('stroke-width', '0.5')
        path.set('id', 'golden-spiral')
        
        return path
    
    def save(self, filename='banner_of_peace.svg'):
        """Save the SVG to file"""
        svg = self.generate_svg()
        tree = ET.ElementTree(svg)
        
        # Pretty print
        ET.indent(tree, space='  ')
        
        # Add XML declaration
        with open(filename, 'wb') as f:
            f.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
            tree.write(f, encoding='utf-8', xml_declaration=False)
        
        print(f"Sacred Banner of Peace saved to {filename}")
        print(f"Embedded sacred properties:")
        print(f"  - Golden ratio (φ): {PHI}")
        print(f"  - Trinity centers at 120° intervals")
        print(f"  - Inner/Outer radius ratio: 1/φ")
        print(f"  - Invisible protection sigil (hexagram)")
        print(f"  - Golden spiral for energy flow")


if __name__ == "__main__":
    # Generate the sacred banner
    banner = SacredBanner(size=300)
    
    # Save to hulylabs.com assets
    banner.save('hulylabs.com/public/banner_of_peace.svg')
    
    # Also save a larger version for high-res displays
    banner_large = SacredBanner(size=600)
    banner_large.save('hulylabs.com/public/banner_of_peace_large.svg')
    
    print("\n✨ The Banner of Peace has been created with sacred protection ✨")