"""
API Module for Python Number Pattern Generator
Author: Molla Samser (Founder, RSK World)
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Year: 2026
Description: Programmatic API for pattern generation and analysis
"""

import json
import time
from typing import Dict, List, Any, Optional, Union
from datetime import datetime
from patterns import PatternAlgorithms, PatternUtils
from animation import PatternAnimator
from config import config


class PatternAPI:
    """Main API class for pattern generation and analysis"""

    def __init__(self):
        """Initialize the Pattern API"""
        self.algorithms = PatternAlgorithms()
        self.animator = PatternAnimator()

        # Available patterns
        self.patterns = {
            'pyramid': 'Pyramid Pattern',
            'reverse_pyramid': 'Reverse Pyramid',
            'triangle': 'Number Triangle',
            'pascal': 'Pascal\'s Triangle',
            'floyd': 'Floyd\'s Triangle',
            'square': 'Number Square',
            'diamond': 'Diamond Pattern',
            'hourglass': 'Hourglass Pattern',
            'spiral': 'Number Spiral',
            'prime': 'Prime Numbers',
            'fibonacci': 'Fibonacci Triangle',
            'multiplication': 'Multiplication Table',
            'magic': 'Magic Square',
            'sierpinski': 'Sierpinski Triangle',
            'mandelbrot': 'Mandelbrot Set',
            'hilbert': 'Hilbert Curve',
            'dragon': 'Dragon Curve',
            'koch': 'Koch Snowflake',
            'cellular': 'Cellular Automaton',
            'binary_tree': 'Binary Tree'
        }

        # Patterns that don't use start_num
        self.patterns_without_start = [
            'pascal', 'prime', 'fibonacci', 'multiplication', 'magic',
            'sierpinski', 'mandelbrot', 'hilbert', 'dragon', 'koch', 'cellular', 'binary_tree'
        ]

    def generate(self, pattern_type: str, size: int, start_num: int = 1,
                include_stats: bool = True, include_metadata: bool = True) -> Dict[str, Any]:
        """Generate a pattern with optional statistics and metadata

        Args:
            pattern_type: Type of pattern to generate
            size: Size parameter for the pattern
            start_num: Starting number (ignored for some patterns)
            include_stats: Whether to include pattern statistics
            include_metadata: Whether to include metadata

        Returns:
            Dictionary containing pattern data
        """
        # Validate inputs
        if not PatternUtils.validate_size(size)[0]:
            raise ValueError(f"Invalid size: {size}. Must be between 1 and {config.get('patterns.max_size.basic', 50)}")

        if pattern_type not in self.patterns_without_start:
            if not PatternUtils.validate_start_number(start_num)[0]:
                raise ValueError(f"Invalid start number: {start_num}. Must be between 0 and {config.get('patterns.max_start_number', 1000)}")

        if pattern_type not in self.patterns:
            raise ValueError(f"Unknown pattern type: {pattern_type}")

        # Generate pattern
        start_time = time.time()

        try:
            if pattern_type == 'pyramid':
                pattern = self.algorithms.pyramid(size, start_num)
            elif pattern_type == 'reverse_pyramid':
                pattern = self.algorithms.reverse_pyramid(size, start_num)
            elif pattern_type == 'triangle':
                pattern = self.algorithms.triangle(size, start_num)
            elif pattern_type == 'pascal':
                pattern = self.algorithms.pascal_triangle(size)
            elif pattern_type == 'floyd':
                pattern = self.algorithms.floyd_triangle(size)
            elif pattern_type == 'square':
                pattern = self.algorithms.square(size, start_num)
            elif pattern_type == 'diamond':
                pattern = self.algorithms.diamond(size, start_num)
            elif pattern_type == 'hourglass':
                pattern = self.algorithms.hourglass(size, start_num)
            elif pattern_type == 'spiral':
                pattern = self.algorithms.spiral(size)
            elif pattern_type == 'prime':
                pattern = self.algorithms.prime_numbers(size)
            elif pattern_type == 'fibonacci':
                pattern = self.algorithms.fibonacci_triangle(size)
            elif pattern_type == 'multiplication':
                pattern = self.algorithms.multiplication_table(size)
            elif pattern_type == 'magic':
                pattern = self.algorithms.magic_square(size)
            elif pattern_type == 'sierpinski':
                pattern = self.algorithms.sierpinski_triangle(min(size, 5))
            elif pattern_type == 'mandelbrot':
                pattern = self.algorithms.mandelbrot_set(min(size, 15))
            elif pattern_type == 'hilbert':
                pattern = self.algorithms.hilbert_curve(min(size, 4))
            elif pattern_type == 'dragon':
                pattern = self.algorithms.dragon_curve(min(size, 8))
            elif pattern_type == 'koch':
                pattern = self.algorithms.koch_snowflake(min(size, 3))
            elif pattern_type == 'cellular':
                pattern = self.algorithms.cellular_automaton(size, start_num if start_num <= 255 else 30)
            elif pattern_type == 'binary_tree':
                pattern = self.algorithms.binary_tree(min(size, 5))
            else:
                raise ValueError(f"Pattern type not implemented: {pattern_type}")

            generation_time = time.time() - start_time

        except Exception as e:
            raise RuntimeError(f"Error generating pattern: {str(e)}")

        # Build response
        response = {
            'pattern': pattern,
            'pattern_type': pattern_type,
            'display_name': self.patterns[pattern_type],
            'size': size,
            'start_num': start_num if pattern_type not in self.patterns_without_start else None,
            'generation_time': round(generation_time, 4)
        }

        if include_stats:
            response['statistics'] = PatternUtils.get_pattern_stats(pattern)

        if include_metadata:
            response['metadata'] = {
                'generator': config.get('app.name'),
                'version': config.get('app.version'),
                'author': config.get('app.author'),
                'designer': config.get('app.designer'),
                'website': config.get('app.website'),
                'generated_at': datetime.now().isoformat(),
                'api_version': '2.0'
            }

        return response

    def batch_generate(self, requests: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Generate multiple patterns in batch

        Args:
            requests: List of pattern generation requests

        Returns:
            List of pattern responses
        """
        results = []

        for req in requests:
            try:
                pattern_type = req.get('pattern_type', 'pyramid')
                size = req.get('size', 5)
                start_num = req.get('start_num', 1)
                include_stats = req.get('include_stats', False)
                include_metadata = req.get('include_metadata', False)

                result = self.generate(pattern_type, size, start_num, include_stats, include_metadata)
                results.append(result)

            except Exception as e:
                results.append({
                    'error': str(e),
                    'pattern_type': req.get('pattern_type', 'unknown'),
                    'request': req
                })

        return results

    def list_patterns(self) -> Dict[str, Any]:
        """Get list of available patterns"""
        return {
            'patterns': self.patterns,
            'patterns_without_start_num': self.patterns_without_start,
            'total_patterns': len(self.patterns),
            'categories': {
                'basic': ['pyramid', 'reverse_pyramid', 'triangle', 'square', 'diamond', 'hourglass'],
                'mathematical': ['pascal', 'floyd', 'fibonacci', 'multiplication', 'magic'],
                'advanced': ['spiral', 'prime', 'cellular', 'binary_tree'],
                'fractal': ['sierpinski', 'mandelbrot', 'hilbert', 'dragon', 'koch']
            }
        }

    def animate(self, pattern_type: str, size: int, start_num: int = 1,
               speed: float = 0.5) -> List[Dict[str, Any]]:
        """Animate pattern generation

        Args:
            pattern_type: Type of pattern to animate
            size: Size parameter
            start_num: Starting number
            speed: Animation speed (not used in programmatic mode)

        Returns:
            List of animation frames with metadata
        """
        frames = []
        step_count = 0

        for frame in self.animator.animate_pattern(pattern_type, size, start_num):
            step_count += 1
            frames.append({
                'step': step_count,
                'pattern': frame,
                'description': f'Step {step_count} of {pattern_type} animation'
            })

        return frames

    def compare_patterns(self, pattern1: Dict[str, Any], pattern2: Dict[str, Any]) -> Dict[str, Any]:
        """Compare two patterns

        Args:
            pattern1: First pattern data
            pattern2: Second pattern data

        Returns:
            Comparison results
        """
        p1_stats = pattern1.get('statistics', {})
        p2_stats = pattern2.get('statistics', {})

        return {
            'pattern1': {
                'type': pattern1.get('pattern_type'),
                'size': pattern1.get('size'),
                'lines': p1_stats.get('lines', 0),
                'characters': p1_stats.get('characters', 0)
            },
            'pattern2': {
                'type': pattern2.get('pattern_type'),
                'size': pattern2.get('size'),
                'lines': p2_stats.get('lines', 0),
                'characters': p2_stats.get('characters', 0)
            },
            'differences': {
                'lines_diff': p2_stats.get('lines', 0) - p1_stats.get('lines', 0),
                'chars_diff': p2_stats.get('characters', 0) - p1_stats.get('characters', 0),
                'size_diff': pattern2.get('size', 0) - pattern1.get('size', 0)
            }
        }

    def export(self, pattern_data: Dict[str, Any], format: str = 'json') -> str:
        """Export pattern data in various formats

        Args:
            pattern_data: Pattern data from generate() method
            format: Export format ('json', 'text', 'csv')

        Returns:
            Formatted export string
        """
        if format == 'json':
            return json.dumps(pattern_data, indent=2, ensure_ascii=False)

        elif format == 'text':
            lines = [
                f"Pattern Generator Export",
                "=" * 40,
                f"Pattern Type: {pattern_data.get('display_name', 'Unknown')}",
                f"Size: {pattern_data.get('size', 'N/A')}",
                f"Start Number: {pattern_data.get('start_num', 'N/A')}",
                f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
                "",
                "Pattern:",
                "-" * 20,
                pattern_data.get('pattern', ''),
                "",
                "=" * 40,
                f"Generated by {config.get('app.name')} v{config.get('app.version')}",
                f"Author: {config.get('app.author')}",
                f"Website: {config.get('app.website')}"
            ]
            return "\n".join(lines)

        elif format == 'csv':
            # Simple CSV format for pattern data
            lines = [
                "Property,Value",
                f"Pattern Type,{pattern_data.get('display_name', 'Unknown')}",
                f"Size,{pattern_data.get('size', 'N/A')}",
                f"Start Number,{pattern_data.get('start_num', 'N/A')}",
                f"Generation Time,{pattern_data.get('generation_time', 'N/A')}",
                f"Lines,{pattern_data.get('statistics', {}).get('lines', 'N/A')}",
                f"Characters,{pattern_data.get('statistics', {}).get('characters', 'N/A')}",
                f"Numbers,{pattern_data.get('statistics', {}).get('numbers', 'N/A')}"
            ]
            return "\n".join(lines)

        else:
            raise ValueError(f"Unsupported export format: {format}")

    def get_pattern_info(self, pattern_type: str) -> Dict[str, Any]:
        """Get detailed information about a pattern type

        Args:
            pattern_type: Type of pattern

        Returns:
            Pattern information dictionary
        """
        if pattern_type not in self.patterns:
            raise ValueError(f"Unknown pattern type: {pattern_type}")

        # Generate a small example
        example = self.generate(pattern_type, 3, include_stats=True)

        return {
            'name': self.patterns[pattern_type],
            'type': pattern_type,
            'description': self._get_pattern_description(pattern_type),
            'uses_start_num': pattern_type not in self.patterns_without_start,
            'category': self._get_pattern_category(pattern_type),
            'complexity': self._get_pattern_complexity(pattern_type),
            'example': {
                'size': 3,
                'pattern': example['pattern'],
                'statistics': example['statistics']
            }
        }

    def _get_pattern_description(self, pattern_type: str) -> str:
        """Get description for a pattern type"""
        descriptions = {
            'pyramid': 'Classic pyramid shape with numbers',
            'reverse_pyramid': 'Inverted pyramid pattern',
            'triangle': 'Right-angled triangle with sequential numbers',
            'pascal': 'Mathematical triangle with binomial coefficients',
            'floyd': 'Sequential numbers in triangular arrangement',
            'square': 'Grid pattern with sequential numbers',
            'diamond': 'Diamond shape with numbers',
            'hourglass': 'Hourglass shape using numbers',
            'spiral': 'Spiral arrangement of numbers',
            'prime': 'Grid displaying prime numbers',
            'fibonacci': 'Triangle pattern using Fibonacci sequence',
            'multiplication': 'Mathematical multiplication table',
            'magic': 'Mathematical magic square (odd sizes only)',
            'sierpinski': 'Fractal triangle pattern',
            'mandelbrot': 'Mandelbrot set visualization',
            'hilbert': 'Hilbert space-filling curve',
            'dragon': 'Dragon curve fractal',
            'koch': 'Koch snowflake fractal',
            'cellular': 'Cellular automaton pattern',
            'binary_tree': 'Binary tree visualization'
        }
        return descriptions.get(pattern_type, 'Pattern description not available')

    def _get_pattern_category(self, pattern_type: str) -> str:
        """Get category for a pattern type"""
        categories = {
            'basic': ['pyramid', 'reverse_pyramid', 'triangle', 'square', 'diamond', 'hourglass'],
            'mathematical': ['pascal', 'floyd', 'fibonacci', 'multiplication', 'magic'],
            'advanced': ['spiral', 'prime', 'cellular', 'binary_tree'],
            'fractal': ['sierpinski', 'mandelbrot', 'hilbert', 'dragon', 'koch']
        }

        for category, patterns in categories.items():
            if pattern_type in patterns:
                return category

        return 'other'

    def _get_pattern_complexity(self, pattern_type: str) -> str:
        """Get complexity level for a pattern type"""
        complexities = {
            'low': ['pyramid', 'reverse_pyramid', 'triangle', 'square'],
            'medium': ['diamond', 'hourglass', 'pascal', 'floyd', 'spiral', 'fibonacci', 'multiplication'],
            'high': ['prime', 'magic', 'cellular', 'binary_tree'],
            'very_high': ['sierpinski', 'mandelbrot', 'hilbert', 'dragon', 'koch']
        }

        for complexity, patterns in complexities.items():
            if pattern_type in patterns:
                return complexity

        return 'unknown'


class PatternAPIClient:
    """Client for using the Pattern API programmatically"""

    def __init__(self):
        """Initialize API client"""
        self.api = PatternAPI()

    def quick_generate(self, pattern_type: str, size: int, start_num: int = 1) -> str:
        """Quickly generate a pattern and return just the pattern string"""
        result = self.api.generate(pattern_type, size, start_num, include_stats=False, include_metadata=False)
        return result['pattern']

    def generate_with_stats(self, pattern_type: str, size: int, start_num: int = 1) -> Dict[str, Any]:
        """Generate pattern with statistics"""
        return self.api.generate(pattern_type, size, start_num, include_stats=True, include_metadata=False)

    def get_all_patterns(self) -> List[str]:
        """Get list of all available pattern types"""
        return list(self.api.patterns.keys())

    def search_patterns(self, query: str) -> List[str]:
        """Search for patterns by name"""
        query = query.lower()
        return [ptype for ptype, name in self.api.patterns.items() if query in name.lower() or query in ptype]

    def benchmark_pattern(self, pattern_type: str, size: int, iterations: int = 5) -> Dict[str, float]:
        """Benchmark pattern generation performance"""
        times = []

        for _ in range(iterations):
            start_time = time.time()
            self.api.generate(pattern_type, size, include_stats=False, include_metadata=False)
            end_time = time.time()
            times.append(end_time - start_time)

        avg_time = sum(times) / len(times)
        min_time = min(times)
        max_time = max(times)

        return {
            'average_time': round(avg_time, 4),
            'min_time': round(min_time, 4),
            'max_time': round(max_time, 4),
            'iterations': iterations,
            'pattern_type': pattern_type,
            'size': size
        }


# Global API instance
api = PatternAPI()
client = PatternAPIClient()


def generate_pattern(pattern_type: str, size: int, start_num: int = 1) -> str:
    """Convenience function for quick pattern generation"""
    return client.quick_generate(pattern_type, size, start_num)


if __name__ == '__main__':
    print("Python Number Pattern Generator - API Module")
    print("=" * 60)
    print("Developed by Molla Samser (RSK World)")
    print("Designed by Rima Khatun")
    print("Website: https://rskworld.in")
    print("Year: 2026")
    print("=" * 60)

    # Example usage
    client = PatternAPIClient()

    # Generate a simple pattern
    print("\n🎯 Quick Pattern Generation:")
    pattern = client.quick_generate('pyramid', 4, 1)
    print(pattern)

    # Generate with statistics
    print("\n📊 Pattern with Statistics:")
    result = client.generate_with_stats('sierpinski', 3)
    print(f"Pattern: {result['display_name']}")
    print(f"Lines: {result['statistics']['lines']}")
    print(f"Generation time: {result['generation_time']}s")

    # List all patterns
    print(f"\n📋 Available Patterns: {len(client.get_all_patterns())}")
    print(", ".join(client.get_all_patterns()))

    # Search patterns
    print("\n🔍 Search Results for 'fractal':")
    fractal_patterns = client.search_patterns('fractal')
    print(", ".join(fractal_patterns))

    # Benchmark
    print("\n⚡ Performance Benchmark:")
    benchmark = client.benchmark_pattern('mandelbrot', 8, 3)
    print(f"Average time: {benchmark['average_time']}s for {benchmark['iterations']} iterations")

    print("\n✅ API demonstrations completed!")
    print("💡 Use this API for programmatic pattern generation")