import pandas as pd
import numpy as np
import logging

logger = logging.getLogger("TradingBot.LiquidityProvider")

class LiquidityProvider:
    def __init__(self, config):
        self.config = config
        self.fib_levels = [-0.618, -1.0, -1.618, -2.0]  # Fibonacci extension levels
        self.min_rr_ratio = self.config.get("min_risk_reward_ratio", 2.0)  # Unified config key

    def calculate_tp_levels(self, signal_type, entry_price, sl_price):
        """Calculate TP levels using Fibonacci extensions."""
        try:
            # Calculate the base move (from entry to SL)
            base_move = abs(entry_price - sl_price)
            
            if signal_type == "BUY":
                # For buys, project up from entry
                tp_levels = {
                    level: entry_price + (abs(level) * base_move)
                    for level in self.fib_levels
                }
                # Use -1.0 as default TP
                default_tp = tp_levels[-1.0]
                logger.info(f"Calculated TP levels for BUY: {tp_levels}")
                
            else:  # SELL
                # For sells, project down from entry
                tp_levels = {
                    level: entry_price - (abs(level) * base_move)
                    for level in self.fib_levels
                }
                # Use -1.0 as default TP
                default_tp = tp_levels[-1.0]
                logger.info(f"Calculated TP levels for SELL: {tp_levels}")

            return default_tp

        except Exception as e:
            logger.error(f"Error calculating TP levels: {str(e)}")
            return None

    def find_tp_zone(self, signal, structure_analysis, data_cache):
        """Find take profit zone based on Fibonacci extensions and market structure."""
        if not signal or "entry_price" not in signal or "stop_loss" not in signal:
            logger.warning("Invalid signal provided for TP calculation")
            return None

        # Calculate TP using Fibonacci extensions
        tp_level = self.calculate_tp_levels(
            signal["type"],
            signal["entry_price"],
            signal["stop_loss"]
        )

        if tp_level is None:
            logger.warning("Could not calculate TP level")
            return None

        logger.info(f"TP level calculated at: {tp_level}")
        return tp_level

# Example Usage (called from main.py / execution_handler.py)
if __name__ == "__main__":
    print("LiquidityProvider module. Run integration test via main.py.")

    # Dummy data for testing
    dummy_signal = {"type": "BUY", "entry_price": 1910.0, "stop_loss": 1905.0, "trigger_time": pd.Timestamp.now(tz='UTC')}
    dummy_structure = {"range_high": 1950.0, "range_low": 1900.0, "midpoint": 1925.0}
    dummy_config = {"trading": {}}

    lp = LiquidityProvider(dummy_config)
    tp = lp.find_tp_zone(dummy_signal, dummy_structure, None) # Data cache not used in this simple version
    print(f"Test 1 (BUY below mid): Entry={dummy_signal['entry_price']}, TP={tp}") # Expect Midpoint 1925.0

    dummy_signal_2 = {"type": "BUY", "entry_price": 1930.0, "stop_loss": 1925.0, "trigger_time": pd.Timestamp.now(tz='UTC')}
    tp_2 = lp.find_tp_zone(dummy_signal_2, dummy_structure, None)
    print(f"Test 2 (BUY above mid): Entry={dummy_signal_2['entry_price']}, TP={tp_2}") # Expect Range High 1950.0

    dummy_signal_3 = {"type": "SELL", "entry_price": 1940.0, "stop_loss": 1945.0, "trigger_time": pd.Timestamp.now(tz='UTC')}
    tp_3 = lp.find_tp_zone(dummy_signal_3, dummy_structure, None)
    print(f"Test 3 (SELL above mid): Entry={dummy_signal_3['entry_price']}, TP={tp_3}") # Expect Midpoint 1925.0

    dummy_signal_4 = {"type": "SELL", "entry_price": 1915.0, "stop_loss": 1920.0, "trigger_time": pd.Timestamp.now(tz='UTC')}
    tp_4 = lp.find_tp_zone(dummy_signal_4, dummy_structure, None)
    print(f"Test 4 (SELL below mid): Entry={dummy_signal_4['entry_price']}, TP={tp_4}") # Expect Range Low 1900.0