"""VerdeVolt wordmark + Solarplants×VerdeVolt lockup PNG generator.

Produces transparent-bg PNGs at 400/800/1600 px widths for each variant.

Variants:
  · verdevolt-positive-{400,800,1600}.png    (VERDEVOLT Ink + PROIECT SRL Copper)
  · verdevolt-negative-{400,800,1600}.png    (VERDEVOLT Bone + PROIECT SRL Copper)
  · lockup-horizontal-positive-{400,800,1600}.png
  · lockup-horizontal-negative-{400,800,1600}.png
  · lockup-vertical-positive-{400,800,1600}.png
  · lockup-vertical-negative-{400,800,1600}.png

Fonts:
  · Inter SemiBold + Bold loaded from local Solarplants/examples/brand-assets/fonts/
  · Falls back to system Helvetica if Inter unavailable.

Output: examples/brand-assets/logos/png/
"""
from PIL import Image, ImageDraw, ImageFont
from pathlib import Path

ROOT = Path("/Users/ordonic/Desktop/AGENTS/Solarplants/examples/brand-assets")
OUT = ROOT / "logos" / "png"
OUT.mkdir(parents=True, exist_ok=True)

# PIL doesn't read OTF/CFF Inter+Fraunces. Use TTF system fallbacks at render time;
# canonical brand fonts (Inter + Fraunces) are loaded by SVG/HTML/Docx/PPTX via Google Fonts.
INTER_BOLD = "/System/Library/Fonts/Supplemental/Arial Bold.ttf"
INTER_SEMIBOLD = "/System/Library/Fonts/Supplemental/Arial Bold.ttf"
INTER_REGULAR = "/System/Library/Fonts/Supplemental/Arial.ttf"
# Fraunces fallback → Georgia (already used in build_brand_pngs.py)
FRAUNCES_72 = "/System/Library/Fonts/Supplemental/Georgia.ttf"

# Brand tokens (RGBA)
INK = (14, 26, 36, 255)
SLATE = (42, 57, 66, 255)
COPPER = (184, 115, 51, 255)
BONE = (244, 241, 236, 255)
GREY = (122, 138, 146, 255)
TRANSPARENT = (0, 0, 0, 0)


def draw_text_centered(draw, x, y_baseline, text, font, fill):
    """Draw text centered horizontally on x, with baseline at y_baseline."""
    w = int(font.getlength(text))
    draw.text((x - w // 2, y_baseline), text, font=font, fill=fill, anchor="ls")


def draw_twin_peaks(draw, x_origin, y_origin, width, height, color, rear_opacity=0.55):
    """Twin Peaks chevron mark."""
    def pt(px, py):
        return (int(x_origin + px / 100 * width),
                int(y_origin + py / 100 * height))

    sw = max(2, int(min(width, height) * 0.10))
    rear = color[:3] + (int(255 * rear_opacity),)
    front = color[:3] + (255,)

    draw.line([pt(9, 100), pt(35, 38)], fill=rear, width=sw, joint="curve")
    draw.line([pt(35, 38), pt(61, 100)], fill=rear, width=sw, joint="curve")
    draw.line([pt(27, 100), pt(53, 18)], fill=front, width=sw, joint="curve")
    draw.line([pt(53, 18), pt(79, 100)], fill=front, width=sw, joint="curve")

    cap_r = sw // 2
    for px, py in [(9, 100), (35, 38), (61, 100)]:
        cx, cy = pt(px, py)
        draw.ellipse([cx - cap_r, cy - cap_r, cx + cap_r, cy + cap_r], fill=rear)
    for px, py in [(27, 100), (53, 18), (79, 100)]:
        cx, cy = pt(px, py)
        draw.ellipse([cx - cap_r, cy - cap_r, cx + cap_r, cy + cap_r], fill=front)


def letterspaced_text(draw, x, y_baseline, text, font, fill, letterspacing_pct=0.06, anchor_center=False):
    """Draw text with manual letterspacing (PIL doesn't support tracking natively).
    Returns the total width drawn.
    """
    chars = list(text)
    em = font.size
    extra = int(em * letterspacing_pct)

    # Compute total width
    char_widths = [int(font.getlength(c)) for c in chars]
    total_w = sum(char_widths) + extra * (len(chars) - 1)

    if anchor_center:
        cursor = x - total_w // 2
    else:
        cursor = x

    for c, cw in zip(chars, char_widths):
        draw.text((cursor, y_baseline), c, font=font, fill=fill, anchor="ls")
        cursor += cw + extra
    return total_w


def render_verdevolt(width_px, text_color, accent_color, bg_color=None):
    """Render VerdeVolt wordmark (single-entity, vertically stacked VERDEVOLT + PROIECT · S.R.L.).
    AspectRatio matches verdevolt-wordmark-primary.svg: 720×140 → 5.14:1
    """
    scale = 4
    W = width_px * scale
    H = int(W / 5.14)  # match svg aspect

    canvas = Image.new("RGBA", (W, H), bg_color if bg_color else TRANSPARENT)
    draw = ImageDraw.Draw(canvas)

    # VERDEVOLT — Inter Bold 64px at 720 width = 0.089 of width → 0.089 * W
    main_font_size = int(W * 0.089)
    sub_font_size = int(W * 0.025)
    main_font = ImageFont.truetype(INTER_BOLD, main_font_size)
    sub_font = ImageFont.truetype(INTER_SEMIBOLD, sub_font_size)

    # Vertical positioning per SVG: text y=76 of 140 = baseline 54%
    main_baseline = int(H * 0.54)
    sub_baseline = int(H * 0.77)

    cx = W // 2
    letterspaced_text(draw, cx, main_baseline, "VERDEVOLT", main_font, text_color,
                      letterspacing_pct=0.06, anchor_center=True)
    letterspaced_text(draw, cx, sub_baseline, "PROIECT · S.R.L.", sub_font, accent_color,
                      letterspacing_pct=0.18, anchor_center=True)

    final_w = width_px
    final_h = int(H * final_w / W)
    return canvas.resize((final_w, final_h), Image.LANCZOS)


def render_lockup_horizontal(width_px, text_color, accent_color, peak_rear_op=0.55, bg_color=None):
    """Render horizontal Solarplants×VerdeVolt lockup.
    Matches solarplants-verdevolt-lockup-horizontal.svg: 1180×140 → 8.43:1

    Layout (left to right):
      [COMMERCIAL BRAND label]  [SolarPlants Fraunces + Twin Peaks]  | hairline |  [LEGAL ENTITY label]  [VERDEVOLT Inter + sub]
    """
    scale = 4
    W = width_px * scale
    H = int(W / 8.43)

    canvas = Image.new("RGBA", (W, H), bg_color if bg_color else TRANSPARENT)
    draw = ImageDraw.Draw(canvas)

    # Fonts
    label_size = int(W * 0.0085)         # 10px @ 1180 width
    solar_size = int(W * 0.054)          # 64px @ 1180 → SolarPlants Fraunces
    verde_main_size = int(W * 0.030)     # 36px @ 1180
    verde_sub_size = int(W * 0.0093)     # 11px @ 1180

    label_font = ImageFont.truetype(INTER_SEMIBOLD, label_size)
    solar_font = ImageFont.truetype(FRAUNCES_72, solar_size)
    verde_main_font = ImageFont.truetype(INTER_BOLD, verde_main_size)
    verde_sub_font = ImageFont.truetype(INTER_SEMIBOLD, verde_sub_size)

    # Y positions per SVG (140 viewBox)
    label_y = int(H * 0.285)        # 40/140
    solar_baseline_y = int(H * 0.685)   # 96/140
    verde_main_baseline_y = int(H * 0.614)  # 86/140
    verde_sub_baseline_y = int(H * 0.771)   # 108/140

    # Hairline X (560/1180 = 47.5%)
    hairline_x = int(W * 0.475)
    hairline_y1 = int(H * 0.214)
    hairline_y2 = int(H * 0.785)

    # === LEFT SIDE: SolarPlants ===
    left_pad = int(W * 0.051)  # 60/1180
    # COMMERCIAL BRAND label
    letterspaced_text(draw, left_pad, label_y, "COMMERCIAL BRAND", label_font, GREY,
                      letterspacing_pct=0.22, anchor_center=False)

    # SolarPlants wordmark — anchored to end at solar_anchor_x (right-aligned)
    solar_anchor_x = int(W * 0.39)  # 460/1180
    solar_w = int(solar_font.getlength("SolarPlants"))
    draw.text((solar_anchor_x - solar_w, solar_baseline_y), "SolarPlants",
              font=solar_font, fill=text_color, anchor="ls")

    # Twin Peaks mark — punctuation-spaced after SolarPlants
    mark_h = int(solar_size * 0.28)
    mark_w = int(mark_h * 50 / 32)
    mark_gap = int(W * 0.006)
    mark_x = solar_anchor_x + mark_gap
    mark_y_top = solar_baseline_y - mark_h
    draw_twin_peaks(draw, mark_x, mark_y_top, mark_w, mark_h, accent_color, peak_rear_op)

    # === HAIRLINE (copper, 1px scaled to canvas) ===
    rule_w = max(2, int(W * 0.001))
    draw.line([(hairline_x, hairline_y1), (hairline_x, hairline_y2)],
              fill=COPPER, width=rule_w)

    # === RIGHT SIDE: VerdeVolt ===
    right_pad = int(W * 0.508)  # 600/1180
    # LEGAL ENTITY label
    letterspaced_text(draw, right_pad, label_y, "LEGAL ENTITY", label_font, GREY,
                      letterspacing_pct=0.22, anchor_center=False)
    # VERDEVOLT main
    letterspaced_text(draw, right_pad, verde_main_baseline_y, "VERDEVOLT",
                      verde_main_font, text_color,
                      letterspacing_pct=0.06, anchor_center=False)
    # PROIECT · S.R.L. · CUI 34742128
    letterspaced_text(draw, right_pad, verde_sub_baseline_y,
                      "PROIECT · S.R.L. · CUI 34742128",
                      verde_sub_font, accent_color,
                      letterspacing_pct=0.20, anchor_center=False)

    final_w = width_px
    final_h = int(H * final_w / W)
    return canvas.resize((final_w, final_h), Image.LANCZOS)


def render_lockup_vertical(width_px, text_color, accent_color, peak_rear_op=0.55, bg_color=None):
    """Render vertical Solarplants×VerdeVolt lockup.
    Aspect ~1:1.5 (width:height) — Solarplants on top, hairline divider, VerdeVolt below.
    """
    scale = 4
    W = width_px * scale
    H = int(W * 1.0)  # square-ish canvas

    canvas = Image.new("RGBA", (W, H), bg_color if bg_color else TRANSPARENT)
    draw = ImageDraw.Draw(canvas)

    # Fonts (sized for vertical proportions)
    label_size = int(W * 0.025)
    solar_size = int(W * 0.13)
    verde_main_size = int(W * 0.075)
    verde_sub_size = int(W * 0.022)

    label_font = ImageFont.truetype(INTER_SEMIBOLD, label_size)
    solar_font = ImageFont.truetype(FRAUNCES_72, solar_size)
    verde_main_font = ImageFont.truetype(INTER_BOLD, verde_main_size)
    verde_sub_font = ImageFont.truetype(INTER_SEMIBOLD, verde_sub_size)

    cx = W // 2

    # Top label
    label_y_top = int(H * 0.10)
    letterspaced_text(draw, cx, label_y_top, "COMMERCIAL BRAND", label_font, GREY,
                      letterspacing_pct=0.22, anchor_center=True)

    # SolarPlants + Twin Peaks (centered as a unit)
    solar_text = "SolarPlants"
    solar_w = int(solar_font.getlength(solar_text))
    mark_h = int(solar_size * 0.28)
    mark_w = int(mark_h * 50 / 32)
    gap = int(W * 0.012)
    unit_w = solar_w + gap + mark_w
    solar_x = cx - unit_w // 2
    solar_baseline = int(H * 0.32)
    draw.text((solar_x, solar_baseline), solar_text, font=solar_font, fill=text_color, anchor="ls")
    mark_x = solar_x + solar_w + gap
    mark_y_top = solar_baseline - mark_h
    draw_twin_peaks(draw, mark_x, mark_y_top, mark_w, mark_h, accent_color, peak_rear_op)

    # Hairline (horizontal divider)
    hairline_y = int(H * 0.50)
    hairline_w = max(2, int(W * 0.003))
    hairline_x1 = int(W * 0.30)
    hairline_x2 = int(W * 0.70)
    draw.line([(hairline_x1, hairline_y), (hairline_x2, hairline_y)],
              fill=COPPER, width=hairline_w)

    # Bottom label
    label_y_bot = int(H * 0.60)
    letterspaced_text(draw, cx, label_y_bot, "LEGAL ENTITY", label_font, GREY,
                      letterspacing_pct=0.22, anchor_center=True)

    # VERDEVOLT
    verde_baseline = int(H * 0.78)
    letterspaced_text(draw, cx, verde_baseline, "VERDEVOLT",
                      verde_main_font, text_color,
                      letterspacing_pct=0.06, anchor_center=True)

    # Subtitle
    sub_baseline = int(H * 0.86)
    letterspaced_text(draw, cx, sub_baseline,
                      "PROIECT · S.R.L. · CUI 34742128",
                      verde_sub_font, accent_color,
                      letterspacing_pct=0.20, anchor_center=True)

    final_w = width_px
    final_h = int(H * final_w / W)
    return canvas.resize((final_w, final_h), Image.LANCZOS)


# ================ Build ================
print("=" * 72)
print("VerdeVolt + Lockup PNG Generator")
print("=" * 72)

SIZES = [400, 800, 1600]

variants = [
    # (name, text_color, accent_color — accent is always Copper)
    ("positive", INK,  COPPER),
    ("negative", BONE, COPPER),
]

print("\n→ VerdeVolt wordmark (5.14:1 aspect):")
for vname, text_c, acc_c in variants:
    for size in SIZES:
        img = render_verdevolt(size, text_c, acc_c)
        path = OUT / f"verdevolt-{vname}-{size}.png"
        img.save(path, "PNG")
        print(f"  ✓ verdevolt-{vname}-{size}.png  ({img.size[0]}×{img.size[1]})")

print("\n→ Solarplants × VerdeVolt Lockup HORIZONTAL (8.43:1):")
for vname, text_c, acc_c in variants:
    for size in SIZES:
        img = render_lockup_horizontal(size, text_c, acc_c)
        path = OUT / f"lockup-horizontal-{vname}-{size}.png"
        img.save(path, "PNG")
        print(f"  ✓ lockup-horizontal-{vname}-{size}.png  ({img.size[0]}×{img.size[1]})")

print("\n→ Solarplants × VerdeVolt Lockup VERTICAL (1:1):")
for vname, text_c, acc_c in variants:
    for size in SIZES:
        img = render_lockup_vertical(size, text_c, acc_c)
        path = OUT / f"lockup-vertical-{vname}-{size}.png"
        img.save(path, "PNG")
        print(f"  ✓ lockup-vertical-{vname}-{size}.png  ({img.size[0]}×{img.size[1]})")

print("\n" + "=" * 72)
total = len(variants) * len(SIZES) * 3
print(f"Generated {total} PNG files in {OUT}")
print("=" * 72)