#!/usr/bin/env python3
"""
Essential Test Suite - Core functionality tests

This file contains the most important tests to verify core functionality:
- Data loading and processing
- Basic model operations  
- Trading signal generation
- Critical utility functions
"""

import sys
import os
import unittest
import logging
from pathlib import Path

# Add project root to path
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

logger = logging.getLogger(__name__)

class TestEssentialFunctionality(unittest.TestCase):
    """Essential tests for core trading system functionality"""
    
    def test_imports(self):
        """Test that all critical modules can be imported"""
        try:
            from core.config import get_config
            from core.data_provider import DataProvider
            from utils.model_utils import robust_save, robust_load
            logger.info("✅ All critical imports successful")
        except ImportError as e:
            self.fail(f"Critical import failed: {e}")
    
    def test_config_loading(self):
        """Test configuration loading"""
        try:
            from core.config import get_config
            config = get_config()
            self.assertIsNotNone(config, "Config should be loaded")
            logger.info("✅ Configuration loading successful")
        except Exception as e:
            self.fail(f"Config loading failed: {e}")
    
    def test_data_provider_initialization(self):
        """Test DataProvider can be initialized"""
        try:
            from core.data_provider import DataProvider
            data_provider = DataProvider(['ETH/USDT'], ['1m'])
            self.assertIsNotNone(data_provider, "DataProvider should initialize")
            logger.info("✅ DataProvider initialization successful")
        except Exception as e:
            self.fail(f"DataProvider initialization failed: {e}")
    
    def test_model_utils(self):
        """Test model utility functions"""
        try:
            from utils.model_utils import get_model_info
            import tempfile
            
            # Test with non-existent file
            info = get_model_info("non_existent_file.pt")
            self.assertFalse(info['exists'], "Should report file doesn't exist")
            
            logger.info("✅ Model utils test successful")
        except Exception as e:
            self.fail(f"Model utils test failed: {e}")
    
    def test_signal_generation_logic(self):
        """Test basic signal generation logic"""
        import numpy as np
        
        # Test signal distribution calculation
        predictions = np.array([0, 1, 2, 1, 0, 2, 1, 1, 2, 0])  # SELL, HOLD, BUY
        
        buy_count = np.sum(predictions == 2)
        sell_count = np.sum(predictions == 0)
        hold_count = np.sum(predictions == 1)
        total = len(predictions)
        
        distribution = {
            "BUY": buy_count / total,
            "SELL": sell_count / total,
            "HOLD": hold_count / total
        }
        
        # Verify calculations
        self.assertAlmostEqual(distribution["BUY"], 0.3, places=1)
        self.assertAlmostEqual(distribution["SELL"], 0.3, places=1)
        self.assertAlmostEqual(distribution["HOLD"], 0.4, places=1)
        self.assertAlmostEqual(sum(distribution.values()), 1.0, places=1)
        
        logger.info("✅ Signal generation logic test successful")

def run_essential_tests():
    """Run essential tests only"""
    suite = unittest.TestLoader().loadTestsFromTestCase(TestEssentialFunctionality)
    runner = unittest.TextTestRunner(verbosity=2)
    result = runner.run(suite)
    return result.wasSuccessful()

if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO)
    logger.info("Running essential functionality tests...")
    
    success = run_essential_tests()
    
    if success:
        logger.info("✅ All essential tests passed!")
        sys.exit(0)
    else:
        logger.error("❌ Essential tests failed!")
        sys.exit(1)