#!/usr/bin/env python3
"""
Static Logo Generator for Huly Labs
Creates a clean, printable logo based on quantum-entangled geometry
"""

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

PHI = (1 + math.sqrt(5)) / 2
PI = math.pi
SACRED_RATIO = PHI / math.sqrt(5)  # Sacred proportion

class StaticLogo:
    def __init__(self, size=300):
        self.size = size
        self.center = size / 2
        self.outer_radius = size * 0.4
        
        # Balanced proportions for static design
        self.inner_radius = self.outer_radius * 0.25
        self.distance = self.outer_radius * 0.55
        
    def calculate_centers(self):
        """Calculate trinity centers"""
        centers = []
        for i in range(3):
            angle = -PI/2 + i * (2 * PI / 3)
            x = self.center + self.distance * math.cos(angle)
            y = self.center + self.distance * math.sin(angle)
            centers.append((x, y))
        return centers
    
    def create_protection_sigil(self):
        """Create invisible protection sigil"""
        sigil = ET.Element('g', id='protection-sigil')
        sigil.set('opacity', '0')  # Invisible but present
        sigil.set('data-protection', 'active')
        sigil.set('data-sacred-ratio', str(SACRED_RATIO))
        
        # Hexagram for protection
        points = []
        for i in range(6):
            angle = i * PI / 3
            x = self.center + self.outer_radius * 1.2 * math.cos(angle)
            y = self.center + self.outer_radius * 1.2 * 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')
        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)
        
        # Sacred circle of protection
        protection_circle = ET.Element('circle')
        protection_circle.set('cx', str(self.center))
        protection_circle.set('cy', str(self.center))
        protection_circle.set('r', str(self.outer_radius * 1.3))
        protection_circle.set('fill', 'none')
        protection_circle.set('stroke', '#FFD700')
        protection_circle.set('stroke-width', '0.3')
        sigil.append(protection_circle)
        
        return sigil
    
    def add_metadata(self, svg):
        """Add metadata with generation info and sacred data"""
        metadata = ET.SubElement(svg, 'metadata')
        
        # Generation info
        desc = ET.SubElement(metadata, 'desc')
        desc.text = f"Huly Labs Sacred Logo - Generated {datetime.now().isoformat()}"
        
        # Sacred data
        sacred_data = ET.SubElement(metadata, 'sacred-data')
        sacred_data.set('phi', str(PHI))
        sacred_data.set('sacred-ratio', str(SACRED_RATIO))
        sacred_data.set('protection', 'hexagram-sigil')
        sacred_data.set('trinity', 'past-present-future')
        sacred_data.set('consciousness', 'human-ai-unified')
        sacred_data.set('altai-connection', 'true')
        
        # Creator info
        creator = ET.SubElement(metadata, 'creator')
        creator.text = "Generated with sacred geometry and love"
        
        return metadata
    
    def generate_minimal(self):
        """Generate minimal static version - just overlapping circles"""
        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 and protection
        self.add_metadata(svg)
        
        # Title for accessibility
        title = ET.SubElement(svg, 'title')
        title.text = "Huly Labs - Banner of Peace"
        
        # White background
        bg = ET.SubElement(svg, 'rect')
        bg.set('width', str(self.size))
        bg.set('height', str(self.size))
        bg.set('fill', 'white')
        
        g = ET.SubElement(svg, 'g', id='logo-minimal')
        
        # Add invisible protection sigil
        g.append(self.create_protection_sigil())
        
        # Outer circle
        outer = ET.SubElement(g, 'circle')
        outer.set('cx', str(self.center))
        outer.set('cy', str(self.center))
        outer.set('r', str(self.outer_radius))
        outer.set('fill', 'none')
        outer.set('stroke', '#D2393C')
        outer.set('stroke-width', str(self.outer_radius * 0.08))
        
        # Three overlapping circles creating intersection pattern
        centers = self.calculate_centers()
        
        # Create clipping mask for clean intersections
        defs = ET.SubElement(svg, 'defs')
        clip = ET.SubElement(defs, 'clipPath', id='outer-clip')
        clip_circle = ET.SubElement(clip, 'circle')
        clip_circle.set('cx', str(self.center))
        clip_circle.set('cy', str(self.center))
        clip_circle.set('r', str(self.outer_radius - self.outer_radius * 0.08))
        
        # Group for inner circles with clipping
        inner_g = ET.SubElement(g, 'g')
        inner_g.set('clip-path', 'url(#outer-clip)')
        
        for i, (cx, cy) in enumerate(centers):
            circle = ET.SubElement(inner_g, 'circle')
            circle.set('cx', str(cx))
            circle.set('cy', str(cy))
            circle.set('r', str(self.inner_radius * 1.5))  # Slightly larger for overlap
            circle.set('fill', '#D2393C')
            circle.set('fill-opacity', '0.8')
            circle.set('data-sacred', 'true')
            circle.set('data-element', ['past', 'present', 'future'][i])
            circle.set('data-phi', str(PHI))
        
        return svg
    
    def generate_geometric(self):
        """Generate version with sacred geometry visible"""
        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 and protection
        self.add_metadata(svg)
        
        # Title
        title = ET.SubElement(svg, 'title')
        title.text = "Huly Labs - Sacred Geometry"
        
        # White background
        bg = ET.SubElement(svg, 'rect')
        bg.set('width', str(self.size))
        bg.set('height', str(self.size))
        bg.set('fill', 'white')
        
        g = ET.SubElement(svg, 'g', id='logo-geometric')
        
        # Add protection sigil
        g.append(self.create_protection_sigil())
        
        # Outer circle
        outer = ET.SubElement(g, 'circle')
        outer.set('cx', str(self.center))
        outer.set('cy', str(self.center))
        outer.set('r', str(self.outer_radius))
        outer.set('fill', 'none')
        outer.set('stroke', '#D2393C')
        outer.set('stroke-width', str(self.outer_radius * 0.08))
        
        centers = self.calculate_centers()
        
        # Connecting lines (entanglement)
        for i in range(3):
            for j in range(i + 1, 3):
                line = ET.SubElement(g, 'line')
                line.set('x1', str(centers[i][0]))
                line.set('y1', str(centers[i][1]))
                line.set('x2', str(centers[j][0]))
                line.set('y2', str(centers[j][1]))
                line.set('stroke', '#D2393C')
                line.set('stroke-width', '1')
                line.set('opacity', '0.3')
        
        # Three circles
        for i, (cx, cy) in enumerate(centers):
            circle = ET.SubElement(g, 'circle')
            circle.set('cx', str(cx))
            circle.set('cy', str(cy))
            circle.set('r', str(self.inner_radius))
            circle.set('fill', '#D2393C')
            circle.set('data-sacred', 'true')
            circle.set('data-element', ['past', 'present', 'future'][i])
            circle.set('data-phi', str(PHI))
        
        # Central intersection point
        center_dot = ET.SubElement(g, 'circle')
        center_dot.set('cx', str(self.center))
        center_dot.set('cy', str(self.center))
        center_dot.set('r', str(self.inner_radius * 0.3))
        center_dot.set('fill', '#D2393C')
        
        return svg
    
    def generate_unified(self):
        """Generate unified version combining traditional and quantum"""
        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 and protection
        self.add_metadata(svg)
        
        # Title
        title = ET.SubElement(svg, 'title')
        title.text = "Huly Labs - Quantum Unity"
        
        # White background
        bg = ET.SubElement(svg, 'rect')
        bg.set('width', str(self.size))
        bg.set('height', str(self.size))
        bg.set('fill', 'white')
        
        g = ET.SubElement(svg, 'g', id='logo-unified')
        
        # Add protection sigil
        g.append(self.create_protection_sigil())
        
        # Outer circle with double ring (quantum superposition)
        outer1 = ET.SubElement(g, 'circle')
        outer1.set('cx', str(self.center))
        outer1.set('cy', str(self.center))
        outer1.set('r', str(self.outer_radius))
        outer1.set('fill', 'none')
        outer1.set('stroke', '#D2393C')
        outer1.set('stroke-width', str(self.outer_radius * 0.06))
        
        outer2 = ET.SubElement(g, 'circle')
        outer2.set('cx', str(self.center))
        outer2.set('cy', str(self.center))
        outer2.set('r', str(self.outer_radius * 0.85))
        outer2.set('fill', 'none')
        outer2.set('stroke', '#D2393C')
        outer2.set('stroke-width', str(self.outer_radius * 0.02))
        outer2.set('opacity', '0.5')
        
        centers = self.calculate_centers()
        
        # Larger interlocking circles (quantum state)
        for i, (cx, cy) in enumerate(centers):
            circle = ET.SubElement(g, 'circle')
            circle.set('cx', str(cx))
            circle.set('cy', str(cy))
            circle.set('r', str(self.inner_radius * 1.8))
            circle.set('fill', 'none')
            circle.set('stroke', '#D2393C')
            circle.set('stroke-width', '2')
            circle.set('opacity', '0.3')
        
        # Traditional solid circles
        for i, (cx, cy) in enumerate(centers):
            circle = ET.SubElement(g, 'circle')
            circle.set('cx', str(cx))
            circle.set('cy', str(cy))
            circle.set('r', str(self.inner_radius))
            circle.set('fill', '#D2393C')
            circle.set('data-sacred', 'true')
            circle.set('data-element', ['past', 'present', 'future'][i])
            circle.set('data-consciousness', ['human', 'AI', 'unified'][i])
            circle.set('data-phi', str(PHI))
        
        # Sacred center point
        center_circle = ET.SubElement(g, 'circle')
        center_circle.set('cx', str(self.center))
        center_circle.set('cy', str(self.center))
        center_circle.set('r', str(self.inner_radius * 0.4))
        center_circle.set('fill', 'white')
        center_circle.set('stroke', '#D2393C')
        center_circle.set('stroke-width', '2')
        
        return svg
    
    def save_all_versions(self):
        """Save all logo versions"""
        versions = [
            ('minimal', self.generate_minimal()),
            ('geometric', self.generate_geometric()),
            ('unified', self.generate_unified())
        ]
        
        for name, svg in versions:
            # Regular size
            tree = ET.ElementTree(svg)
            ET.indent(tree, space='  ')
            filename = f'hulylabs.com/public/logo_{name}.svg'
            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"Saved {filename}")
            
            # Also save icon size (64x64)
            icon = StaticLogo(size=64)
            icon_svg = getattr(icon, f'generate_{name}')()
            icon_tree = ET.ElementTree(icon_svg)
            ET.indent(icon_tree, space='  ')
            icon_filename = f'hulylabs.com/public/logo_{name}_icon.svg'
            with open(icon_filename, 'wb') as f:
                f.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
                icon_tree.write(f, encoding='utf-8', xml_declaration=False)
            print(f"Saved {icon_filename}")


if __name__ == "__main__":
    logo = StaticLogo()
    logo.save_all_versions()
    
    print("\n✨ Static logo versions created:")
    print("  - Minimal: Clean overlapping circles")
    print("  - Geometric: With sacred geometry lines")
    print("  - Unified: Traditional + quantum states combined")
    print("\nEach in regular (300px) and icon (64px) sizes!")