MINMAXINDEX - 最小最大值索引

min_idx, max_idx = TA.MINMAXINDEX(records, timeperiod)

def main():
    records = exchange.GetRecords()
    if len(records) < 30:
        return
    
    closes = [r['Close'] for r in records]
    
    # 获取20周期的最小最大值索引
    min_idx, max_idx = TA.MINMAXINDEX(closes, 20)
    
    bars_since_low = min_idx[-1]
    bars_since_high = max_idx[-1]
    
    Log(f"最低点在 {bars_since_low} 根K线前")
    Log(f"最高点在 {bars_since_high} 根K线前")
    
    # 判断趋势
    if bars_since_high < bars_since_low:
        Log("最近高点在低点之后 -> 可能上涨")
    elif bars_since_low < bars_since_high:
        Log("最近低点在高点之后 -> 可能下跌")
    else:
        Log("高低点同时出现（异常）")

def swing_points_analysis():
    records = exchange.GetRecords()
    highs = [r['High'] for r in records[-50:]]
    lows = [r['Low'] for r in records[-50:]]
    
    # 获取30周期的高低点位置
    min_idx, max_idx = TA.MINMAXINDEX(lows, 30)
    
    bars_since_low = min_idx[-1]
    bars_since_high = max_idx[-1]
    
    # 有效波段：高低点相距5根K线以上
    if abs(bars_since_high - bars_since_low) >= 5:
        Log("识别到有效波段:")
        
        if bars_since_high < bars_since_low:
            # 先低后高 - 上涨波段
            Log(f"  上涨波段: 低点({bars_since_low}根前) -> 高点({bars_since_high}根前)")
            swing_type = "UP_SWING"
        else:
            # 先高后低 - 下跌波段
            Log(f"  下跌波段: 高点({bars_since_high}根前) -> 低点({bars_since_low}根前)")
            swing_type = "DOWN_SWING"
        
        # 波段完整性：高低点都不在最近3根K线内
        if bars_since_low > 3 and bars_since_high > 3:
            Log("  波段已完成，可能反转")
            return swing_type, "COMPLETED"
        else:
            Log("  波段进行中")
            return swing_type, "ONGOING"
    
    return None, None

def trend_direction():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-50:]]
    
    # 使用不同周期
    min_idx_20, max_idx_20 = TA.MINMAXINDEX(closes, 20)
    min_idx_50, max_idx_50 = TA.MINMAXINDEX(closes, 50)
    
    # 短周期
    recent_low_pos = min_idx_20[-1]
    recent_high_pos = max_idx_20[-1]
    
    # 长周期
    long_low_pos = min_idx_50[-1]
    long_high_pos = max_idx_50[-1]
    
    Log(f"20周期: 低点{recent_low_pos}根前, 高点{recent_high_pos}根前")
    Log(f"50周期: 低点{long_low_pos}根前, 高点{long_high_pos}根前")
    
    # 强势上涨：短期和长期的高点都很近，低点都很远
    if recent_high_pos <= 3 and long_high_pos <= 10:
        if recent_low_pos > 10 and long_low_pos > 20:
            Log("强势上涨趋势")
            return "STRONG_UPTREND"
    
    # 强势下跌：短期和长期的低点都很近，高点都很远
    elif recent_low_pos <= 3 and long_low_pos <= 10:
        if recent_high_pos > 10 and long_high_pos > 20:
            Log("强势下跌趋势")
            return "STRONG_DOWNTREND"
    
    # 震荡：高低点交替出现
    elif abs(recent_high_pos - recent_low_pos) < 5:
        Log("震荡行情")
        return "RANGING"
    
    return "NEUTRAL"

def entry_timing():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-30:]]
    
    min_idx, max_idx = TA.MINMAXINDEX(closes, 30)
    
    bars_since_low = min_idx[-1]
    bars_since_high = max_idx[-1]
    
    current_price = closes[-1]
    low_price = closes[-bars_since_low - 1] if bars_since_low > 0 else current_price
    high_price = closes[-bars_since_high - 1] if bars_since_high > 0 else current_price
    
    # 做多时机：低点后3-8根K线，且高点较远
    if 3 <= bars_since_low <= 8 and bars_since_high > 10:
        bounce = (current_price - low_price) / low_price * 100
        
        if 2 <= bounce <= 8:
            Log(f"理想做多时机: 低点后{bars_since_low}根K线，反弹{bounce:.1f}%")
            return "LONG_ENTRY"
    
    # 做空时机：高点后3-8根K线，且低点较远
    elif 3 <= bars_since_high <= 8 and bars_since_low > 10:
        pullback = (high_price - current_price) / high_price * 100
        
        if 2 <= pullback <= 8:
            Log(f"理想做空时机: 高点后{bars_since_high}根K线，回落{pullback:.1f}%")
            return "SHORT_ENTRY"
    
    return "WAIT"

def dynamic_stop_loss():
    records = exchange.GetRecords()
    highs = [r['High'] for r in records[-20:]]
    lows = [r['Low'] for r in records[-20:]]
    closes = [r['Close'] for r in records[-20:]]
    
    # 获取最近高低点位置
    min_idx, max_idx = TA.MINMAXINDEX(closes, 20)
    
    bars_since_low = min_idx[-1]
    bars_since_high = max_idx[-1]
    
    # 多头止损
    if bars_since_low <= 5:
        # 最近创新低，使用紧密止损
        stop_loss_long = min(lows[-3:])
        Log(f"紧密止损(最近创新低): {stop_loss_long:.2f}")
    else:
        # 低点较远，使用波段低点
        swing_low = lows[-bars_since_low - 1] if bars_since_low > 0 else lows[-1]
        stop_loss_long = swing_low * 0.98  # 留2%缓冲
        Log(f"波段低点止损({bars_since_low}根前): {stop_loss_long:.2f}")
    
    # 空头止损
    if bars_since_high <= 5:
        stop_loss_short = max(highs[-3:])
        Log(f"紧密止损(最近创新高): {stop_loss_short:.2f}")
    else:
        swing_high = highs[-bars_since_high - 1] if bars_since_high > 0 else highs[-1]
        stop_loss_short = swing_high * 1.02
        Log(f"波段高点止损({bars_since_high}根前): {stop_loss_short:.2f}")
    
    return stop_loss_long, stop_loss_short

def market_structure():
    records = exchange.GetRecords()
    closes = [r['Close'] for r in records[-100:]]
    
    # 分析最近50根K线的结构
    min_idx, max_idx = TA.MINMAXINDEX(closes, 50)
    
    bars_since_low = min_idx[-1]
    bars_since_high = max_idx[-1]
    
    # 获取价格
    current = closes[-1]
    low = closes[-bars_since_low - 1] if bars_since_low > 0 else current
    high = closes[-bars_since_high - 1] if bars_since_high > 0 else current
    
    # 高低点的时间序列
    if bars_since_high < bars_since_low:
        # 先低后高
        structure = "HIGHER_HIGH"
        Log(f"市场结构: 更高的高点 (低点{bars_since_low}根前 -> 高点{bars_since_high}根前)")
        
        # 检查是否也创了更高的低点
        if bars_since_low < 40:  # 低点不太远
            Log("  可能形成上升趋势（高低点抬高）")
            return "UPTREND_STRUCTURE"
    
    else:
        # 先高后低
        structure = "LOWER_LOW"
        Log(f"市场结构: 更低的低点 (高点{bars_since_high}根前 -> 低点{bars_since_low}根前)")
        
        if bars_since_high < 40:
            Log("  可能形成下降趋势（高低点降低）")
            return "DOWNTREND_STRUCTURE"
    
    return structure