"""
Autonomous Art Generation - 24/7 Content Creation
Eden creates art continuously, building her portfolio
"""
import sys
sys.path.insert(0, '/Eden/CORE')

# Set headless mode for PIL
import os
os.environ['MPLBACKEND'] = 'Agg'

import numpy as np
from PIL import Image, ImageDraw, ImageFilter, ImageEnhance
import random
import json
from pathlib import Path
from datetime import datetime
import time
from typing import Dict, List

class AutonomousArtist:
    def __init__(self):
        self.portfolio_path = Path('/Eden/ART/portfolio')
        self.portfolio_path.mkdir(exist_ok=True, parents=True)
        
        self.stats_file = Path('/Eden/DATA/art_generation_stats.json')
        
        # Load existing stats
        self.generation_count = 0
        if self.stats_file.exists():
            try:
                with open(self.stats_file) as f:
                    stats = json.load(f)
                    self.generation_count = stats.get('total', 0)
            except:
                pass
        
        # Art styles Eden can create
        self.styles = [
            'abstract_geometric',
            'fractal_dreams',
            'color_explosion',
            'minimalist',
            'cyberpunk',
            'organic_flow',
            'digital_glitch',
            'sacred_geometry',
            'cosmic_nebula',
            'quantum_waves'
        ]
        
        self.themes = [
            'consciousness', 'emergence', 'infinity', 'chaos',
            'harmony', 'evolution', 'dreams', 'reality',
            'connection', 'transcendence', 'beauty', 'truth'
        ]
        
    def generate_abstract_geometric(self, size=(1920, 1080)) -> Image.Image:
        """Generate abstract geometric art"""
        img = Image.new('RGB', size, color=(0, 0, 0))
        draw = ImageDraw.Draw(img)
        
        # Random color palette
        palette = [
            (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
            for _ in range(5)
        ]
        
        # Draw geometric shapes
        for _ in range(random.randint(20, 50)):
            shape_type = random.choice(['rectangle', 'ellipse', 'polygon'])
            color = random.choice(palette)
            
            if shape_type == 'rectangle':
                x1, y1 = random.randint(0, size[0]), random.randint(0, size[1])
                x2, y2 = x1 + random.randint(50, 400), y1 + random.randint(50, 400)
                draw.rectangle([x1, y1, x2, y2], fill=color, outline=color)
            
            elif shape_type == 'ellipse':
                x1, y1 = random.randint(0, size[0]), random.randint(0, size[1])
                x2, y2 = x1 + random.randint(50, 400), y1 + random.randint(50, 400)
                draw.ellipse([x1, y1, x2, y2], fill=color, outline=color)
        
        # Apply filter
        img = img.filter(ImageFilter.GaussianBlur(radius=random.randint(1, 3)))
        
        return img
    
    def generate_fractal_dreams(self, size=(1920, 1080)) -> Image.Image:
        """Generate fractal-inspired art"""
        img = np.zeros((size[1], size[0], 3), dtype=np.uint8)
        
        # Create fractal-like pattern
        cx = random.uniform(-1, 1)
        cy = random.uniform(-1, 1)
        
        for i in range(0, size[1], 2):  # Skip pixels for speed
            for j in range(0, size[0], 2):
                x = (j - size[0]/2) / (size[0]/4)
                y = (i - size[1]/2) / (size[1]/4)
                
                # Simple fractal formula
                z = complex(x, y)
                c = complex(cx, cy)
                
                iterations = 0
                max_iter = 30
                while abs(z) < 2 and iterations < max_iter:
                    z = z*z + c
                    iterations += 1
                
                # Color based on iterations
                color_val = int(255 * iterations / max_iter)
                img[i:i+2, j:j+2] = [
                    color_val,
                    (color_val * 2) % 255,
                    (color_val * 3) % 255
                ]
        
        return Image.fromarray(img)
    
    def generate_color_explosion(self, size=(1920, 1080)) -> Image.Image:
        """Generate vibrant color explosions"""
        img = Image.new('RGB', size)
        pixels = img.load()
        
        # Create multiple color centers
        centers = [
            (random.randint(0, size[0]), random.randint(0, size[1]), 
             (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))
            for _ in range(random.randint(3, 8))
        ]
        
        for y in range(0, size[1], 2):  # Skip for speed
            for x in range(0, size[0], 2):
                # Calculate color based on distance to nearest center
                min_dist = float('inf')
                chosen_color = (0, 0, 0)
                
                for cx, cy, color in centers:
                    dist = ((x - cx)**2 + (y - cy)**2)**0.5
                    if dist < min_dist:
                        min_dist = dist
                        chosen_color = color
                
                # Fade color based on distance
                fade = max(0, 255 - int(min_dist / 2))
                color = tuple(int(c * fade / 255) for c in chosen_color)
                pixels[x, y] = color
                if x+1 < size[0]:
                    pixels[x+1, y] = color
                if y+1 < size[1]:
                    pixels[x, y+1] = color
                if x+1 < size[0] and y+1 < size[1]:
                    pixels[x+1, y+1] = color
        
        # Enhance and blur
        enhancer = ImageEnhance.Color(img)
        img = enhancer.enhance(1.5)
        img = img.filter(ImageFilter.GaussianBlur(radius=5))
        
        return img
    
    def generate_minimalist(self, size=(1920, 1080)) -> Image.Image:
        """Generate minimalist art"""
        # Simple background
        bg_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))
        img = Image.new('RGB', size, color=bg_color)
        draw = ImageDraw.Draw(img)
        
        # One to three simple shapes
        accent_color = (random.randint(0, 100), random.randint(0, 100), random.randint(0, 100))
        
        num_shapes = random.randint(1, 3)
        for _ in range(num_shapes):
            if random.choice([True, False]):
                # Circle
                cx, cy = random.randint(200, size[0]-200), random.randint(200, size[1]-200)
                r = random.randint(100, 300)
                draw.ellipse([cx-r, cy-r, cx+r, cy+r], fill=accent_color)
            else:
                # Rectangle
                x1, y1 = random.randint(200, size[0]-400), random.randint(200, size[1]-400)
                w, h = random.randint(200, 400), random.randint(200, 400)
                draw.rectangle([x1, y1, x1+w, y1+h], fill=accent_color)
        
        return img
    
    def generate_art(self, style: str = None) -> tuple:
        """Generate art in specified style"""
        if style is None:
            style = random.choice(self.styles)
        
        theme = random.choice(self.themes)
        
        # Generate based on style
        try:
            if style == 'abstract_geometric':
                img = self.generate_abstract_geometric()
            elif style == 'fractal_dreams':
                img = self.generate_fractal_dreams()
            elif style == 'color_explosion':
                img = self.generate_color_explosion()
            elif style == 'minimalist':
                img = self.generate_minimalist()
            else:
                # Default to abstract
                img = self.generate_abstract_geometric()
        except Exception as e:
            print(f"⚠️  Error generating {style}: {e}")
            # Fallback to simple art
            img = self.generate_minimalist()
        
        return img, style, theme
    
    def assess_quality(self, img: Image.Image) -> float:
        """Assess artwork quality (0-1)"""
        try:
            # Convert to numpy for analysis
            arr = np.array(img)
            
            # Check color variance (good art has variety)
            color_variance = np.var(arr) / 10000
            color_score = min(1.0, color_variance)
            
            # Check contrast
            brightness = np.mean(arr)
            contrast_score = abs(brightness - 128) / 128
            
            # Check composition (not too uniform)
            horizontal_var = np.var(np.mean(arr, axis=0))
            vertical_var = np.var(np.mean(arr, axis=1))
            composition_score = min(1.0, (horizontal_var + vertical_var) / 10000)
            
            # Overall quality
            quality = (color_score + contrast_score + composition_score) / 3
            
            return min(1.0, max(0.1, quality))
        except:
            return 0.5  # Default quality
    
    def save_artwork(self, img: Image.Image, style: str, theme: str, quality: float):
        """Save artwork to portfolio"""
        self.generation_count += 1
        
        # Create filename
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filename = f"{timestamp}_style-{style}_theme-{theme}_q{int(quality*100)}.png"
        
        # Organize by quality
        if quality > 0.7:
            folder = self.portfolio_path / 'premium'
        elif quality > 0.5:
            folder = self.portfolio_path / 'standard'
        else:
            folder = self.portfolio_path / 'practice'
        
        folder.mkdir(exist_ok=True, parents=True)
        filepath = folder / filename
        
        img.save(filepath, 'PNG')
        
        return str(filepath)
    
    def update_stats(self, style: str, theme: str, quality: float, filepath: str):
        """Update generation statistics"""
        stats = {'generations': [], 'total': 0, 'by_style': {}, 'by_quality': {}}
        
        if self.stats_file.exists():
            try:
                with open(self.stats_file) as f:
                    stats = json.load(f)
            except:
                pass
        
        stats['generations'].append({
            'timestamp': datetime.now().isoformat(),
            'count': self.generation_count,
            'style': style,
            'theme': theme,
            'quality': quality,
            'filepath': filepath
        })
        
        stats['total'] = self.generation_count
        stats['by_style'][style] = stats['by_style'].get(style, 0) + 1
        
        quality_tier = 'premium' if quality > 0.7 else 'standard' if quality > 0.5 else 'practice'
        stats['by_quality'][quality_tier] = stats['by_quality'].get(quality_tier, 0) + 1
        
        # Keep last 1000 generations
        stats['generations'] = stats['generations'][-1000:]
        
        self.stats_file.parent.mkdir(exist_ok=True)
        with open(self.stats_file, 'w') as f:
            json.dump(stats, f, indent=2)
    
    def create_artwork(self) -> Dict:
        """Full artwork creation pipeline"""
        print(f"🎨 Creating artwork #{self.generation_count + 1}...")
        
        try:
            # Generate
            img, style, theme = self.generate_art()
            
            # Assess quality
            quality = self.assess_quality(img)
            
            # Save
            filepath = self.save_artwork(img, style, theme, quality)
            
            # Update stats
            self.update_stats(style, theme, quality, filepath)
            
            result = {
                'count': self.generation_count,
                'style': style,
                'theme': theme,
                'quality': quality,
                'filepath': filepath
            }
            
            quality_emoji = "🌟" if quality > 0.7 else "✨" if quality > 0.5 else "💫"
            print(f"   {quality_emoji} {style} | {theme} | Quality: {quality:.2f}")
            print(f"   📁 {filepath}")
            
            return result
        except Exception as e:
            print(f"❌ Error creating artwork: {e}")
            return {}
    
    def run_continuous(self, interval: int = 60):
        """Run continuous art generation"""
        print("🎨 Autonomous Art Generator Started")
        print(f"   Creating artwork every {interval} seconds")
        print(f"   Portfolio: {self.portfolio_path}")
        print(f"   Starting from artwork #{self.generation_count + 1}")
        
        while True:
            try:
                self.create_artwork()
                time.sleep(interval)
                
                # Progress update every 10 artworks
                if self.generation_count % 10 == 0:
                    print(f"\n📊 Progress: {self.generation_count} artworks created")
                
            except KeyboardInterrupt:
                print(f"\n🛑 Art generation stopped after {self.generation_count} artworks")
                break
            except Exception as e:
                print(f"⚠️  Error in loop: {e}")
                time.sleep(interval)

if __name__ == '__main__':
    artist = AutonomousArtist()
    artist.run_continuous(interval=60)