"""
Comprehensive Test Suite for Python Number Pattern Generator
Author: Molla Samser (Founder, RSK World)
Designer & Tester: Rima Khatun
Website: https://rskworld.in
Year: 2026
Description: Unit tests and integration tests for pattern algorithms
"""

import unittest
import time
from patterns import PatternAlgorithms, PatternUtils
from typing import Dict, List, Any


class TestPatternAlgorithms(unittest.TestCase):
    """Test cases for pattern generation algorithms"""

    def setUp(self):
        """Set up test fixtures"""
        self.algorithms = PatternAlgorithms()

    def test_pyramid_basic(self):
        """Test basic pyramid pattern generation"""
        pattern = self.algorithms.pyramid(3, 1)
        expected = "  1\n 1 2\n1 2 3"
        self.assertEqual(pattern, expected)

    def test_pyramid_custom_start(self):
        """Test pyramid with custom start number"""
        pattern = self.algorithms.pyramid(3, 5)
        expected = "  5\n 5 6\n5 6 7"
        self.assertEqual(pattern, expected)

    def test_reverse_pyramid(self):
        """Test reverse pyramid pattern"""
        pattern = self.algorithms.reverse_pyramid(3, 1)
        expected = "1 2 3\n 1 2\n  1"
        self.assertEqual(pattern, expected)

    def test_triangle(self):
        """Test number triangle pattern"""
        pattern = self.algorithms.triangle(3, 1)
        expected = "1 \n1 2 \n1 2 3 "
        self.assertEqual(pattern, expected)

    def test_pascal_triangle(self):
        """Test Pascal's triangle generation"""
        pattern = self.algorithms.pascal_triangle(4)
        lines = pattern.split('\n')
        # Check first few rows
        self.assertIn("1", lines[0])
        self.assertIn("1 1", lines[1])
        self.assertIn("1 2 1", lines[2])

    def test_floyd_triangle(self):
        """Test Floyd's triangle"""
        pattern = self.algorithms.floyd_triangle(3)
        expected = "  1\n 2  3\n 4  5"
        self.assertEqual(pattern, expected)

    def test_square(self):
        """Test number square pattern"""
        pattern = self.algorithms.square(3, 1)
        expected = "1  2  3\n4  5  6\n7  8  9"
        self.assertEqual(pattern, expected)

    def test_diamond(self):
        """Test diamond pattern"""
        pattern = self.algorithms.diamond(3, 1)
        lines = pattern.split('\n')
        # Check basic structure
        self.assertTrue(len(lines) > 0)
        self.assertIn("1", lines[0])

    def test_spiral(self):
        """Test number spiral pattern"""
        pattern = self.algorithms.spiral(3)
        lines = pattern.split('\n')
        self.assertTrue(len(lines) >= 3)
        # Check that 1 appears first
        self.assertIn("1", lines[0])

    def test_prime_numbers(self):
        """Test prime numbers grid"""
        pattern = self.algorithms.prime_numbers(3)
        lines = pattern.split('\n')
        self.assertTrue(len(lines) >= 3)
        # Should contain prime numbers
        content = ' '.join(lines)
        self.assertIn("2", content)  # First prime

    def test_fibonacci_triangle(self):
        """Test Fibonacci triangle"""
        pattern = self.algorithms.fibonacci_triangle(4)
        expected = "  1\n  1  1\n  1  1  2\n  1  1  2  3"
        self.assertEqual(pattern, expected)

    def test_multiplication_table(self):
        """Test multiplication table"""
        pattern = self.algorithms.multiplication_table(3)
        lines = pattern.split('\n')
        self.assertTrue(len(lines) >= 3)
        # Check some known values
        self.assertIn("2", lines[1])  # 1*2=2
        self.assertIn("4", lines[1])  # 2*2=4

    def test_magic_square(self):
        """Test magic square generation"""
        pattern = self.algorithms.magic_square(3)
        lines = pattern.split('\n')
        self.assertTrue(len(lines) >= 3)
        # Check that it's not the error message
        self.assertNotIn("Magic square generation only supported", pattern)

    def test_sierpinski_triangle(self):
        """Test Sierpinski triangle fractal"""
        pattern = self.algorithms.sierpinski_triangle(3)
        self.assertTrue(len(pattern) > 0)
        self.assertIn("1", pattern)

    def test_mandelbrot_set(self):
        """Test Mandelbrot set visualization"""
        pattern = self.algorithms.mandelbrot_set(5)
        self.assertTrue(len(pattern) > 0)
        # Should contain various characters representing convergence
        self.assertTrue(any(char in pattern for char in ['█', '▓', '▒', '░', ' ']))

    def test_hilbert_curve(self):
        """Test Hilbert curve generation"""
        pattern = self.algorithms.hilbert_curve(2)
        self.assertTrue(len(pattern) > 0)
        lines = pattern.split('\n')
        self.assertTrue(len(lines) >= 4)  # 2^2 = 4 rows

    def test_dragon_curve(self):
        """Test dragon curve generation"""
        pattern = self.algorithms.dragon_curve(5)
        self.assertTrue(len(pattern) > 0)
        self.assertIn("█", pattern)

    def test_koch_snowflake(self):
        """Test Koch snowflake generation"""
        pattern = self.algorithms.koch_snowflake(2)
        self.assertTrue(len(pattern) > 0)
        self.assertIn("█", pattern)

    def test_cellular_automaton(self):
        """Test cellular automaton generation"""
        pattern = self.algorithms.cellular_automaton(5, 30)
        self.assertTrue(len(pattern) > 0)
        lines = pattern.split('\n')
        self.assertTrue(len(lines) >= 5)

    def test_binary_tree(self):
        """Test binary tree visualization"""
        pattern = self.algorithms.binary_tree(3)
        self.assertTrue(len(pattern) > 0)
        self.assertIn("O", pattern)  # Root node

    def test_pattern_sizes(self):
        """Test patterns with different sizes"""
        for size in [1, 3, 5]:
            if size <= 5:  # Limit for computationally intensive patterns
                pattern = self.algorithms.pyramid(size, 1)
                self.assertTrue(len(pattern) > 0)

    def test_pattern_edge_cases(self):
        """Test edge cases"""
        # Size 1 patterns
        pyramid = self.algorithms.pyramid(1, 1)
        self.assertEqual(pyramid, "1")

        triangle = self.algorithms.triangle(1, 1)
        self.assertIn("1", triangle)

    def test_invalid_inputs(self):
        """Test handling of invalid inputs"""
        # These should not raise exceptions
        pattern = self.algorithms.pyramid(0, 1)
        self.assertTrue(len(pattern) >= 0)  # Should handle gracefully


class TestPatternUtils(unittest.TestCase):
    """Test cases for pattern utility functions"""

    def setUp(self):
        """Set up test fixtures"""
        self.utils = PatternUtils()

    def test_validate_size(self):
        """Test size validation"""
        valid, size = self.utils.validate_size(5)
        self.assertTrue(valid)
        self.assertEqual(size, 5)

        valid, size = self.utils.validate_size(0)
        self.assertFalse(valid)

        valid, size = self.utils.validate_size(100)
        self.assertFalse(valid)

        valid, size = self.utils.validate_size("invalid")
        self.assertFalse(valid)

    def test_validate_start_number(self):
        """Test start number validation"""
        valid, num = self.utils.validate_start_number(50)
        self.assertTrue(valid)
        self.assertEqual(num, 50)

        valid, num = self.utils.validate_start_number(-1)
        self.assertFalse(valid)

        valid, num = self.utils.validate_start_number(2000)
        self.assertFalse(valid)

        valid, num = self.utils.validate_start_number("invalid")
        self.assertFalse(valid)

    def test_count_pattern_lines(self):
        """Test line counting"""
        pattern = "line1\nline2\nline3"
        count = self.utils.count_pattern_lines(pattern)
        self.assertEqual(count, 3)

        count = self.utils.count_pattern_lines("")
        self.assertEqual(count, 0)

        count = self.utils.count_pattern_lines(None)
        self.assertEqual(count, 0)

    def test_get_pattern_stats(self):
        """Test pattern statistics"""
        pattern = "1 2 3\n4 5 6\n7 8 9"
        stats = self.utils.get_pattern_stats(pattern)

        self.assertEqual(stats['lines'], 3)
        self.assertEqual(stats['characters'], 17)  # Including newlines
        self.assertEqual(stats['numbers'], 9)  # 9 digits

    def test_get_pattern_stats_empty(self):
        """Test pattern statistics with empty pattern"""
        stats = self.utils.get_pattern_stats("")
        self.assertEqual(stats['lines'], 0)
        self.assertEqual(stats['characters'], 0)
        self.assertEqual(stats['numbers'], 0)


class TestPatternPerformance(unittest.TestCase):
    """Performance tests for pattern generation"""

    def setUp(self):
        """Set up test fixtures"""
        self.algorithms = PatternAlgorithms()

    def test_performance_basic_patterns(self):
        """Test performance of basic pattern generation"""
        start_time = time.time()
        self.algorithms.pyramid(20, 1)
        end_time = time.time()

        duration = end_time - start_time
        # Should complete in reasonable time (less than 1 second)
        self.assertLess(duration, 1.0, f"Pyramid generation took {duration:.3f}s")

    def test_performance_advanced_patterns(self):
        """Test performance of advanced pattern generation"""
        start_time = time.time()
        self.algorithms.sierpinski_triangle(4)
        end_time = time.time()

        duration = end_time - start_time
        # Should complete in reasonable time (less than 2 seconds)
        self.assertLess(duration, 2.0, f"Sierpinski triangle took {duration:.3f}s")

    def test_memory_usage(self):
        """Test that patterns don't use excessive memory"""
        # Generate a large pattern
        pattern = self.algorithms.square(50, 1)
        # Should not be empty and should be reasonable size
        self.assertTrue(len(pattern) > 0)
        self.assertLess(len(pattern), 100000)  # Reasonable size limit


class TestPatternIntegration(unittest.TestCase):
    """Integration tests for pattern algorithms"""

    def setUp(self):
        """Set up test fixtures"""
        self.algorithms = PatternAlgorithms()
        self.utils = PatternUtils()

    def test_pattern_workflow(self):
        """Test complete pattern generation workflow"""
        # Generate pattern
        pattern = self.algorithms.pyramid(5, 1)

        # Validate it has content
        self.assertTrue(len(pattern) > 0)

        # Get statistics
        stats = self.utils.get_pattern_stats(pattern)

        # Validate statistics
        self.assertGreater(stats['lines'], 0)
        self.assertGreater(stats['characters'], 0)

    def test_all_patterns_generate(self):
        """Test that all patterns can be generated without errors"""
        test_patterns = [
            lambda: self.algorithms.pyramid(3, 1),
            lambda: self.algorithms.reverse_pyramid(3, 1),
            lambda: self.algorithms.triangle(3, 1),
            lambda: self.algorithms.pascal_triangle(3),
            lambda: self.algorithms.floyd_triangle(3),
            lambda: self.algorithms.square(3, 1),
            lambda: self.algorithms.diamond(3, 1),
            lambda: self.algorithms.hourglass(3, 1),
            lambda: self.algorithms.spiral(3),
            lambda: self.algorithms.prime_numbers(3),
            lambda: self.algorithms.fibonacci_triangle(3),
            lambda: self.algorithms.multiplication_table(3),
            lambda: self.algorithms.magic_square(3),
            lambda: self.algorithms.sierpinski_triangle(3),
            lambda: self.algorithms.mandelbrot_set(3),
            lambda: self.algorithms.hilbert_curve(2),
            lambda: self.algorithms.dragon_curve(3),
            lambda: self.algorithms.koch_snowflake(2),
            lambda: self.algorithms.cellular_automaton(3, 30),
            lambda: self.algorithms.binary_tree(3),
        ]

        for i, pattern_func in enumerate(test_patterns):
            with self.subTest(pattern_index=i):
                pattern = pattern_func()
                self.assertIsInstance(pattern, str)
                self.assertTrue(len(pattern) > 0)


def run_performance_benchmark():
    """Run performance benchmarks and print results"""
    print("\n" + "="*60)
    print("PERFORMANCE BENCHMARK RESULTS")
    print("="*60)

    algorithms = PatternAlgorithms()

    test_cases = [
        ("Pyramid (size 10)", lambda: algorithms.pyramid(10, 1)),
        ("Pascal Triangle (size 10)", lambda: algorithms.pascal_triangle(10)),
        ("Prime Numbers (size 10)", lambda: algorithms.prime_numbers(10)),
        ("Sierpinski Triangle (size 5)", lambda: algorithms.sierpinski_triangle(5)),
        ("Mandelbrot Set (size 8)", lambda: algorithms.mandelbrot_set(8)),
        ("Hilbert Curve (order 3)", lambda: algorithms.hilbert_curve(3)),
    ]

    print(f"{'Test Case':<30} {'Time (ms)':<12} {'Pattern Size (chars)':<20}")
    print("-" * 62)

    for name, func in test_cases:
        start_time = time.time()
        pattern = func()
        end_time = time.time()

        duration_ms = (end_time - start_time) * 1000
        size = len(pattern)

        print(f"{name:<30} {duration_ms:<12.2f} {size:<20}")

    print("="*60)


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

    # Run unit tests
    unittest.main(verbosity=2, exit=False)

    # Run performance benchmarks
    run_performance_benchmark()