"""
Flask Web Application for Python Number Pattern Generator
Author: Molla Samser (Founder, RSK World)
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Year: 2026
Description: Full web interface for pattern generation
"""

from flask import Flask, render_template, request, jsonify, send_file, make_response
from patterns import PatternAlgorithms, PatternUtils
import json
import io
from datetime import datetime

app = Flask(__name__)
app.config['SECRET_KEY'] = 'rsk-world-pattern-generator-2026'

# Initialize pattern algorithms
algorithms = PatternAlgorithms()

# Available patterns
PATTERN_TYPES = {
    '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
PATTERNS_WITHOUT_START_NUM = [
    'pascal', 'prime', 'fibonacci', 'multiplication', 'magic',
    'sierpinski', 'mandelbrot', 'hilbert', 'dragon', 'koch', 'cellular', 'binary_tree'
]

@app.route('/')
def index():
    """Main page"""
    return render_template('index.html',
                         patterns=PATTERN_TYPES,
                         current_year=datetime.now().year)

@app.route('/generate', methods=['POST'])
def generate_pattern():
    """Generate pattern via AJAX"""
    try:
        data = request.get_json()
        pattern_type = data.get('pattern_type', 'pyramid')
        size = int(data.get('size', 5))
        start_num = int(data.get('start_num', 1))

        # Validate inputs
        if not PatternUtils.validate_size(size)[0]:
            return jsonify({'error': 'Invalid size. Must be between 1 and 50.'})

        if pattern_type not in PATTERNS_WITHOUT_START_NUM:
            if not PatternUtils.validate_start_number(start_num)[0]:
                return jsonify({'error': 'Invalid start number. Must be between 0 and 1000.'})

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

        # Get pattern statistics
        stats = PatternUtils.get_pattern_stats(pattern)

        return jsonify({
            'pattern': pattern,
            'stats': stats,
            'pattern_type': PATTERN_TYPES.get(pattern_type, pattern_type),
            'size': size,
            'start_num': start_num
        })

    except Exception as e:
        return jsonify({'error': f'Error generating pattern: {str(e)}'})

@app.route('/api/patterns', methods=['GET'])
def get_patterns():
    """Get list of available patterns"""
    return jsonify({
        'patterns': PATTERN_TYPES,
        'patterns_without_start_num': PATTERNS_WITHOUT_START_NUM
    })

@app.route('/api/generate/<pattern_type>', methods=['GET'])
def api_generate_pattern(pattern_type):
    """REST API for pattern generation"""
    try:
        size = int(request.args.get('size', 5))
        start_num = int(request.args.get('start_num', 1))

        # Validate inputs
        if not PatternUtils.validate_size(size)[0]:
            return jsonify({'error': 'Invalid size'}), 400

        if pattern_type not in PATTERNS_WITHOUT_START_NUM:
            if not PatternUtils.validate_start_number(start_num)[0]:
                return jsonify({'error': 'Invalid start number'}), 400

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

        return jsonify({
            'pattern': pattern,
            'pattern_type': PATTERN_TYPES.get(pattern_type, pattern_type),
            'size': size,
            'start_num': start_num if pattern_type not in PATTERNS_WITHOUT_START_NUM else None
        })

    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/export/<pattern_type>', methods=['POST'])
def export_pattern(pattern_type):
    """Export pattern as file"""
    try:
        data = request.get_json()
        size = int(data.get('size', 5))
        start_num = int(data.get('start_num', 1))
        format_type = data.get('format', 'txt')

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

        # Create file content
        filename = f"pattern_{pattern_type}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        content = f"Python Number Pattern Generator\n"
        content += "=" * 40 + "\n"
        content += f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
        content += f"Pattern Type: {PATTERN_TYPES.get(pattern_type, pattern_type)}\n"
        content += f"Size: {size}\n"
        if pattern_type not in PATTERNS_WITHOUT_START_NUM:
            content += f"Start Number: {start_num}\n"
        content += "\n" + "=" * 40 + "\n"
        content += "Pattern Output:\n"
        content += "-" * 20 + "\n\n"
        content += pattern
        content += "\n\n" + "=" * 40 + "\n"
        content += "Generated by Python Number Pattern Generator\n"
        content += "Developed by Molla Samser (RSK World)\n"
        content += "Designed by Rima Khatun\n"
        content += "Website: https://rskworld.in\n"
        content += "© 2026 RSK World. All rights reserved.\n"

        if format_type == 'txt':
            response = make_response(content)
            response.headers['Content-Type'] = 'text/plain'
            response.headers['Content-Disposition'] = f'attachment; filename={filename}.txt'
        else:
            # JSON format
            response = make_response(json.dumps({
                'pattern': pattern,
                'metadata': {
                    'pattern_type': PATTERN_TYPES.get(pattern_type, pattern_type),
                    'size': size,
                    'start_num': start_num if pattern_type not in PATTERNS_WITHOUT_START_NUM else None,
                    'generated_at': datetime.now().isoformat(),
                    'generator': 'Python Number Pattern Generator',
                    'author': 'Molla Samser (RSK World)',
                    'designer': 'Rima Khatun'
                }
            }, indent=2))
            response.headers['Content-Type'] = 'application/json'
            response.headers['Content-Disposition'] = f'attachment; filename={filename}.json'

        return response

    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/health')
def health_check():
    """Health check endpoint"""
    return jsonify({
        'status': 'healthy',
        'version': '2.0',
        'patterns_available': len(PATTERN_TYPES),
        'timestamp': datetime.now().isoformat()
    })

if __name__ == '__main__':
    print("Starting Python Number Pattern Generator Web App...")
    print("Developed by Molla Samser (RSK World)")
    print("Designed by Rima Khatun")
    print("Website: https://rskworld.in")
    print("© 2026 RSK World. All rights reserved.")
    print("\nVisit http://localhost:5000 to access the web interface")
    print("API endpoints available at http://localhost:5000/api/")
    app.run(debug=True, host='0.0.0.0', port=5000)