import os
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import math

os.makedirs('images', exist_ok=True)

candle_types = [
    'Bull_1', 'Bull_2', 'Bull_3', 'Bull_4', 
    'Bear_1', 'Bear_2', 'Bear_3', 'Bear_4',
    'Doji_1', 'Doji_2', 'Doji_3', 'Doji_4'
]

alignments = [
    'GAP_UP', 'GAP_DOWN', 'ENGULFING', 'HARAMI', 
    'OVERLAP_UPPER', 'OVERLAP_LOWER', 'PIERCING_CLOUD',
    'EQUAL_OPEN', 'OPEN_EQUALS_HIGH', 'OPEN_EQUALS_LOW', 'CONTINUATION',
    'CLOSE_EQUALS_OPEN', 'CLOSE_EQUALS_HIGH', 'CLOSE_EQUALS_LOW', 'MEETING_LINES',
    'HIGH_EQUALS_OPEN', 'EQUAL_HIGH', 'HIGH_EQUALS_LOW', 'HIGH_EQUALS_CLOSE',
    'LOW_EQUALS_OPEN', 'LOW_EQUALS_HIGH', 'EQUAL_LOW', 'LOW_EQUALS_CLOSE'
]

def get_base_candle(c_type, base_y=50.0, body_size=10.0, wick_size=5.0):
    half_body = body_size / 2.0
    top_body = base_y + half_body
    bot_body = base_y - half_body
    
    if c_type == 'Bull_1': # H > C > O > L
        return (bot_body, top_body + wick_size, bot_body - wick_size, top_body)
    elif c_type == 'Bull_2': # C=H > O > L
        return (bot_body, top_body, bot_body - wick_size, top_body)
    elif c_type == 'Bull_3': # H > C > O=L
        return (bot_body, top_body + wick_size, bot_body, top_body)
    elif c_type == 'Bull_4': # C=H > O=L
        return (bot_body, top_body, bot_body, top_body)
    elif c_type == 'Bear_1': # H > O > C > L
        return (top_body, top_body + wick_size, bot_body - wick_size, bot_body)
    elif c_type == 'Bear_2': # H > O > C=L
        return (top_body, top_body + wick_size, bot_body, bot_body)
    elif c_type == 'Bear_3': # H=O > C > L
        return (top_body, top_body, bot_body - wick_size, bot_body)
    elif c_type == 'Bear_4': # H=O > C=L
        return (top_body, top_body, bot_body, bot_body)
    elif c_type == 'Doji_1':
        return (base_y, base_y + wick_size + half_body, base_y - wick_size - half_body, base_y)
    elif c_type == 'Doji_2':
        return (base_y, base_y, base_y - wick_size - half_body, base_y)
    elif c_type == 'Doji_3':
        return (base_y, base_y + wick_size + half_body, base_y, base_y)
    elif c_type == 'Doji_4':
        return (base_y, base_y, base_y, base_y)

def get_c2(type1, align, type2):
    c1_body_size = 10.0
    c1_wick_size = 5.0
    O1, H1, L1, C1 = get_base_candle(type1, 50.0, c1_body_size, c1_wick_size)
    top1 = max(O1, C1)
    bot1 = min(O1, C1)
    mid1 = (O1 + C1) / 2.0
    
    c2_body_size = 10.0
    c2_wick_size = 5.0
    base_y = 50.0
    
    if align == 'GAP_UP':
        base_y = H1 + c2_body_size/2.0 + c2_wick_size + 2.0
    elif align == 'GAP_DOWN':
        base_y = L1 - c2_body_size/2.0 - c2_wick_size - 2.0
    elif align == 'ENGULFING':
        c2_body_size = c1_body_size * 1.5
        c2_wick_size = c1_wick_size * 1.5
        base_y = mid1
    elif align == 'HARAMI':
        c2_body_size = c1_body_size * 0.5
        c2_wick_size = c1_wick_size * 0.5
        base_y = mid1
    elif align == 'OVERLAP_UPPER':
        base_y = top1
    elif align == 'OVERLAP_LOWER':
        base_y = bot1
    elif align == 'PIERCING_CLOUD':
        c2_body_size = 18.0
        base_y = mid1 + 4.0
    elif align == 'EQUAL_OPEN':
        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
    elif align == 'OPEN_EQUALS_HIGH':
        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
    elif align == 'OPEN_EQUALS_LOW':
        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
    elif align == 'CONTINUATION':
        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[0])
    elif align == 'CLOSE_EQUALS_OPEN':
        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
    elif align == 'CLOSE_EQUALS_HIGH':
        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
    elif align == 'CLOSE_EQUALS_LOW':
        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
    elif align == 'MEETING_LINES':
        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[3])
    elif align == 'HIGH_EQUALS_OPEN':
        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
    elif align == 'EQUAL_HIGH':
        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
    elif align == 'HIGH_EQUALS_LOW':
        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
    elif align == 'HIGH_EQUALS_CLOSE':
        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[1])
    elif align == 'LOW_EQUALS_OPEN':
        base_y += (O1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
    elif align == 'LOW_EQUALS_HIGH':
        base_y += (H1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
    elif align == 'EQUAL_LOW':
        base_y += (L1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
    elif align == 'LOW_EQUALS_CLOSE':
        base_y += (C1 - get_base_candle(type2, 50.0, c2_body_size, c2_wick_size)[2])
        
    return get_base_candle(type2, base_y, c2_body_size, c2_wick_size)

def is_bullish(O, C): return C > O
def is_bearish(O, C): return C < O

def determine_standard_name(c1_type, O1, H1, L1, C1, c2_type, O2, H2, L2, C2):
    # This remains simple heuristic, exact namings aren't fully robust for 3000+ combinations
    return "-"

def draw_candle(ax, x, O, H, L, C):
    if C > O: color = 'green'
    elif C < O: color = 'red'
    else: color = 'black'
    
    ax.plot([x, x], [L, H], color=color, linewidth=2)
    top = max(O, C)
    bottom = min(O, C)
    height = max(top - bottom, 0.2) if top == bottom else (top - bottom)
    rect = patches.Rectangle((x - 0.3, bottom if top != bottom else bottom - 0.1), 0.6, height, linewidth=1, edgecolor=color, facecolor=color)
    ax.add_patch(rect)

def get_pattern_desc(align):
    descriptions = {
        'GAP_UP': 'C2 completely above C1',
        'GAP_DOWN': 'C2 completely below C1',
        'ENGULFING': 'C2 body engulfs C1 body',
        'HARAMI': 'C2 body inside C1 body',
        'OVERLAP_UPPER': 'C2 centered on C1 High/Open',
        'OVERLAP_LOWER': 'C2 centered on C1 Low/Close',
        'PIERCING_CLOUD': 'Large gap and heavy overlap',
        'EQUAL_OPEN': 'O2 = O1',
        'OPEN_EQUALS_HIGH': 'O2 = H1',
        'OPEN_EQUALS_LOW': 'O2 = L1',
        'CONTINUATION': 'O2 = C1',
        'CLOSE_EQUALS_OPEN': 'C2 = O1',
        'CLOSE_EQUALS_HIGH': 'C2 = H1',
        'CLOSE_EQUALS_LOW': 'C2 = L1',
        'MEETING_LINES': 'C2 = C1',
        'HIGH_EQUALS_OPEN': 'H2 = O1',
        'EQUAL_HIGH': 'H2 = H1',
        'HIGH_EQUALS_LOW': 'H2 = L1',
        'HIGH_EQUALS_CLOSE': 'H2 = C1',
        'LOW_EQUALS_OPEN': 'L2 = O1',
        'LOW_EQUALS_HIGH': 'L2 = H1',
        'EQUAL_LOW': 'L2 = L1',
        'LOW_EQUALS_CLOSE': 'L2 = C1'
    }
    return descriptions.get(align, align)

def get_candle_logic(c_type, suffix):
    if c_type == 'Bull_1': return f"H{suffix} > C{suffix} & O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} > L{suffix}"
    elif c_type == 'Bull_2': return f"(C{suffix} = H{suffix}) > O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} > L{suffix}"
    elif c_type == 'Bull_3': return f"H{suffix} > C{suffix} & O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} = L{suffix}"
    elif c_type == 'Bull_4': return f"(C{suffix} = H{suffix}) > O{suffix} & L{suffix} <br> C{suffix} > O{suffix} & L{suffix} <br> O{suffix} = L{suffix}"
    elif c_type == 'Bear_1': return f"L{suffix} < C{suffix} & O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} < H{suffix}"
    elif c_type == 'Bear_2': return f"(C{suffix} = L{suffix}) < O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} < H{suffix}"
    elif c_type == 'Bear_3': return f"L{suffix} < C{suffix} & O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} = H{suffix}"
    elif c_type == 'Bear_4': return f"(C{suffix} = L{suffix}) < O{suffix} & H{suffix} <br> C{suffix} < O{suffix} & H{suffix} <br> O{suffix} = H{suffix}"
    elif c_type == 'Doji_1': return f"H{suffix} > C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} > L{suffix}"
    elif c_type == 'Doji_2': return f"H{suffix} = C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} > L{suffix}"
    elif c_type == 'Doji_3': return f"H{suffix} > C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} = L{suffix}"
    elif c_type == 'Doji_4': return f"H{suffix} = C{suffix} & O{suffix} <br> C{suffix} = O{suffix} <br> C{suffix} & O{suffix} = L{suffix}"
    return ""

def get_alignment_logic(align):
    logic_map = {
        'GAP_UP': 'L_C0 > H_C-1',
        'GAP_DOWN': 'H_C0 < L_C-1',
        'ENGULFING': '(max(O_C0, C_C0) > max(O_C-1, C_C-1)) & (min(O_C0, C_C0) < min(O_C-1, C_C-1))',
        'HARAMI': '(max(O_C0, C_C0) < max(O_C-1, C_C-1)) & (min(O_C0, C_C0) > min(O_C-1, C_C-1))',
        'OVERLAP_UPPER': '((O_C0 + C_C0) / 2) = max(O_C-1, C_C-1)',
        'OVERLAP_LOWER': '((O_C0 + C_C0) / 2) = min(O_C-1, C_C-1)',
        'PIERCING_CLOUD': '(O_C0 > H_C-1) & (C_C0 < ((O_C-1 + C_C-1)/2))',
        'EQUAL_OPEN': 'O_C0 = O_C-1',
        'OPEN_EQUALS_HIGH': 'O_C0 = H_C-1',
        'OPEN_EQUALS_LOW': 'O_C0 = L_C-1',
        'CONTINUATION': 'O_C0 = C_C-1',
        'CLOSE_EQUALS_OPEN': 'C_C0 = O_C-1',
        'CLOSE_EQUALS_HIGH': 'C_C0 = H_C-1',
        'CLOSE_EQUALS_LOW': 'C_C0 = L_C-1',
        'MEETING_LINES': 'C_C0 = C_C-1',
        'HIGH_EQUALS_OPEN': 'H_C0 = O_C-1',
        'EQUAL_HIGH': 'H_C0 = H_C-1',
        'HIGH_EQUALS_LOW': 'H_C0 = L_C-1',
        'HIGH_EQUALS_CLOSE': 'H_C0 = C_C-1',
        'LOW_EQUALS_OPEN': 'L_C0 = O_C-1',
        'LOW_EQUALS_HIGH': 'L_C0 = H_C-1',
        'EQUAL_LOW': 'L_C0 = L_C-1',
        'LOW_EQUALS_CLOSE': 'L_C0 = C_C-1'
    }
    return logic_map.get(align, "")

def get_logic_string(c1_type, align, c2_type):
    lines1 = get_candle_logic(c1_type, "_C-1")
    lines2 = get_candle_logic(c2_type, "_C0")
    align_rule = get_alignment_logic(align)
    return f"{{ <br> {lines1} <br> {lines2} <br> {align_rule} <br> }}"

patterns = []

# Generate all patterns
for t1 in candle_types:
    for align in alignments:
        for t2 in candle_types:
            patterns.append((t1, align, t2))

total_patterns = len(patterns)
patterns_per_img = 10

markdown_lines = []
markdown_lines.append(f"# Complete Exhaustive Set of 2-Candle Patterns (Total: {total_patterns})")
markdown_lines.append("")
markdown_lines.append("| Code_Name | Pattern_Description | Pattern_Logic | Standard_Name | Image Reference |")
markdown_lines.append("|---|---|---|---|---|")

for i in range(0, total_patterns, patterns_per_img):
    batch = patterns[i:i+patterns_per_img]
    
    fig, axes = plt.subplots(2, 5, figsize=(20, 8))
    fig.subplots_adjust(hspace=0.4, wspace=0.3)
    axes = axes.flatten()
    
    for ax in axes:
        ax.set_visible(False)
        
    for j, (t1, align, t2) in enumerate(batch):
        ax = axes[j]
        ax.set_visible(True)
        
        O1, H1, L1, C1 = get_base_candle(t1, 50.0, 10.0, 5.0)
        O2, H2, L2, C2 = get_c2(t1, align, t2)
        
        draw_candle(ax, 1, O1, H1, L1, C1)
        draw_candle(ax, 2, O2, H2, L2, C2)
        
        min_y = min(L1, L2) - 5
        max_y = max(H1, H2) + 5
        ax.set_ylim(min_y, max_y)
        ax.set_xlim(0, 3)
        ax.set_xticks([])
        ax.set_yticks([])
        
        code_name = f"{t1}_{align}_{t2}"
        std_name = determine_standard_name(t1, O1, H1, L1, C1, t2, O2, H2, L2, C2)
        desc = get_pattern_desc(align)
        
        ax.set_title(f"{code_name}", fontsize=9)
        
        img_name = f"plot_{i//patterns_per_img + 1}.png"
        logic_str = get_logic_string(t1, align, t2)
        markdown_lines.append(f"| {code_name} | {desc} | {logic_str} | {std_name} | {img_name} |")
        
    img_path = os.path.join('images', img_name)
    plt.savefig(img_path, bbox_inches='tight')
    plt.close(fig)

with open('2C_patterns.md', 'w') as f:
    f.write("\n".join(markdown_lines))

print(f"Generated {total_patterns} patterns and saved to images folder. MD written to 2C_patterns.md")