#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Business风格（商务风格）海报模板
"""

import logging
import math
import random
from collections import Counter
from typing import Dict, Any, Optional, List, Tuple

import numpy as np
from PIL import Image, ImageDraw, ImageFont
import colorsys

from .base_template import BaseTemplate

logger = logging.getLogger(__name__)


class BusinessTemplate(BaseTemplate):
    """
    商务风格模板，适用于酒店、房地产、高端服务等场景。
    特点是上下图片融合，中间为信息展示区，整体风格沉稳、专业。
    """

    def __init__(self, size: Tuple[int, int] = (900, 1200)):
        super().__init__(size)
        self.config = {
            'total_parts': 4.0,
            'transparent_ratio': 0.5,
            'dynamic_spacing': {
                'min_line_spacing': 8,
                'max_line_spacing': 25,
                'content_margin': 20,
                'section_spacing': 35,
                'bottom_reserve': 40
            }
        }
        self.color_themes = {
            "modern_blue": [(25, 52, 85), (65, 120, 180)],
            "warm_sunset": [(45, 25, 20), (180, 100, 60)],
            "fresh_green": [(15, 45, 25), (90, 140, 80)],
            "deep_ocean": [(20, 40, 70), (70, 140, 200)],
            "elegant_purple": [(35, 25, 55), (120, 90, 160)],
            "classic_gray": [(30, 35, 40), (120, 130, 140)],
            "premium_gold": [(60, 50, 30), (160, 140, 100)],
            "tech_gradient": [(20, 30, 50), (80, 100, 140)]
        }
        self._current_background_colors = None

    def generate(self,
                 top_image_path: str,
                 bottom_image_path: str,
                 content: Dict[str, Any],
                 small_image_paths: Optional[List[str]] = None,
                 color_theme: Optional[str] = None,
                 **kwargs) -> Image.Image:
        """
        生成Business风格海报

        Args:
            top_image_path (str): 顶部图像路径
            bottom_image_path (str): 底部图像路径
            content (Dict[str, Any]): 包含所有文本信息的字典
            small_image_paths (Optional[List[str]]): 中间小图路径列表 (最多3张)
            color_theme (Optional[str]): 预设颜色主题名称

        Returns:
            Image.Image: 生成的海报图像
        """
        top_img = self.image_processor.load_image(top_image_path)
        bottom_img = self.image_processor.load_image(bottom_image_path)
        if not top_img or not bottom_img:
            return None

        top_img = self.image_processor.resize_and_crop(top_img, (self.width, top_img.height))
        bottom_img = self.image_processor.resize_and_crop(bottom_img, (self.width, bottom_img.height))

        if color_theme and color_theme in self.color_themes:
            top_color, bottom_color = self.color_themes[color_theme]
        else:
            top_color = self._extract_dominant_color_edge(top_img)
            bottom_color = self._extract_dominant_color_edge(bottom_img)
            top_color, bottom_color = self._ensure_colors_harmony(top_color, bottom_color)
        
        self._current_background_colors = (top_color, bottom_color)
        canvas = self.create_gradient_background(top_color, bottom_color)

        top_img_trans = self._apply_top_transparency(top_img)
        bottom_img_trans = self._apply_bottom_transparency(bottom_img)

        section_heights = self._calculate_section_heights()
        canvas = self._compose_images(canvas, top_img_trans, bottom_img_trans)
        
        if small_image_paths:
            canvas = self._add_small_images(canvas, small_image_paths, section_heights)

        canvas = self._add_decorative_elements(canvas)
        canvas = self._render_texts(canvas, content, section_heights)
        
        return canvas

    def _calculate_section_heights(self) -> Dict[str, int]:
        """计算各区域高度（1:2:1的比例）"""
        total_height = self.height
        total_parts = self.config['total_parts']
        
        top_h = int(total_height / total_parts)
        middle_h = int(total_height * 2 / total_parts)
        bottom_h = total_height - top_h - middle_h
        
        return {
            'top_height': top_h, 'middle_height': middle_h, 'bottom_height': bottom_h,
            'middle_start': top_h, 'middle_end': top_h + middle_h
        }

    def _apply_top_transparency(self, image: Image.Image) -> Image.Image:
        """对上部图像应用从不透明到透明的渐变"""
        img_rgba = self.image_processor.ensure_rgba(image)
        img_array = np.array(img_rgba)
        h = img_array.shape[0]
        
        start_y = int(h * (1 - self.config['transparent_ratio']))
        for y in range(start_y, h):
            ratio = ((y - start_y) / (h - start_y)) ** 2
            img_array[y, :, 3] = np.clip(img_array[y, :, 3] * (1 - ratio), 0, 255)
            
        return Image.fromarray(img_array)

    def _apply_bottom_transparency(self, image: Image.Image) -> Image.Image:
        """对下部图像应用从透明到不透明的渐变"""
        img_rgba = self.image_processor.ensure_rgba(image)
        img_array = np.array(img_rgba)
        h = img_array.shape[0]

        end_y = int(h * self.config['transparent_ratio'])
        for y in range(end_y):
            ratio = (1 - y / end_y) ** 2
            img_array[y, :, 3] = np.clip(img_array[y, :, 3] * (1 - ratio), 0, 255)
            
        return Image.fromarray(img_array)

    def _compose_images(self, canvas: Image.Image, top_img: Image.Image, bottom_img: Image.Image) -> Image.Image:
        """合成背景和上下图像"""
        canvas.paste(top_img, ((self.width - top_img.width) // 2, 0), top_img)
        canvas.paste(bottom_img, ((self.width - bottom_img.width) // 2, self.height - bottom_img.height), bottom_img)
        return canvas

    def _render_texts(self, canvas: Image.Image, content: Dict[str, Any], heights: Dict[str, int]) -> Image.Image:
        """渲染所有文本内容"""
        draw = ImageDraw.Draw(canvas)
        center_x = self.width // 2
        
        text_start_y, text_end_y = heights['middle_start'], heights['middle_end']
        available_height = text_end_y - text_start_y - self.config['dynamic_spacing']['content_margin'] * 2
        estimated_height = self._estimate_content_height(content, self.width)
        
        layout_params = self._calculate_dynamic_layout_params(estimated_height, available_height)
        
        current_y = text_start_y + self.config['dynamic_spacing']['content_margin']
        available_width = int(self.width * 0.9)
        margin_x = (self.width - available_width) // 2

        current_y = self._render_title(draw, content.get("name", ""), current_y, center_x, self.width, layout_params)
        current_y = self._render_feature(draw, content.get("feature", ""), current_y, center_x, available_width, layout_params)
        self._render_info_section(draw, content, current_y, margin_x, available_width, layout_params, text_end_y)
        
        return canvas

    def _add_small_images(self, canvas: Image.Image, image_paths: List[str], heights: Dict[str, int]) -> Image.Image:
        """在中间区域添加最多三张小图"""
        if not image_paths: return canvas
        
        num_images = min(len(image_paths), 3)
        padding = 10
        total_img_width = int(self.width * 0.8)
        img_width = (total_img_width - (num_images - 1) * padding) // num_images
        img_height = int(img_width * 0.75)
        
        start_x = (self.width - total_img_width) // 2
        y_pos = heights['middle_start'] + (heights['middle_height'] - img_height) // 2

        for i, path in enumerate(image_paths[:num_images]):
            if img := self.image_processor.load_image(path):
                img = self.image_processor.resize_and_crop(img, (img_width, img_height))
                x_pos = start_x + i * (img_width + padding)
                canvas.paste(img, (x_pos, y_pos))
        return canvas

    def _add_decorative_elements(self, canvas: Image.Image) -> Image.Image:
        """添加装饰性元素增强设计感"""
        overlay = Image.new('RGBA', self.size, (0, 0, 0, 0))
        draw = ImageDraw.Draw(overlay)
        
        # 顶部装饰线条
        line_y = self.height // 4 - 20
        for i in range(w := self.width // 3):
            alpha = int(255 * (1 - abs(i - w//2) / (w//2)) * 0.3)
            draw.line([((self.width-w)//2 + i, line_y), ((self.width-w)//2 + i, line_y + 2)], fill=(255,255,255,alpha), width=1)

        # 角落装饰
        s, a = 80, 40
        draw.arc([20, 20, 20+s, 20+s], 180, 270, fill=(255,255,255,a), width=3)
        draw.arc([self.width-s-20, self.height-s-20, self.width-20, self.height-20], 0, 90, fill=(255,255,255,a), width=3)

        return Image.alpha_composite(canvas, overlay)

    def _estimate_content_height(self, content: Dict[str, Any], width: int) -> int:
        """预估内容总高度"""
        spacing = self.config['dynamic_spacing']['section_spacing']
        title_h = int(self.text_renderer.load_font(60).getbbox("T")[3] * 1.2)
        feature_h = int(self.text_renderer.load_font(30).getbbox("T")[3] * 1.5) + 50
        info_h = len(content.get("info_list", [])) * 35
        price_h = 80
        return 20 + title_h + spacing + feature_h + spacing + info_h + price_h + self.config['dynamic_spacing']['bottom_reserve']

    def _calculate_dynamic_layout_params(self, estimated_height: int, available_height: int) -> Dict[str, Any]:
        """根据空间利用率计算动态布局参数"""
        ratio = estimated_height / available_height if available_height > 0 else 1.0
        factor = 1.2 if ratio <= 0.8 else (0.8 if ratio > 1.0 else 1.0)
        spacing = self.config['dynamic_spacing']
        return {
            'line_spacing': int(spacing['min_line_spacing'] + (spacing['max_line_spacing'] - spacing['min_line_spacing']) * factor),
            'section_spacing': int(spacing['section_spacing'] * factor)
        }

    def _render_title(self, draw: ImageDraw.Draw, text: str, y: int, center_x: int, width: int, params: Dict[str, Any]) -> int:
        """渲染主标题"""
        size, calculated_width = self.text_renderer.calculate_font_size_and_width(text, int(width * 0.85), max_size=80)
        font = self.text_renderer.load_font(size)
        text_w, text_h = self.text_renderer.get_text_size(text, font)
        self.text_renderer.draw_text_with_outline(draw, (center_x - text_w // 2, y), text, font, text_color=(255, 240, 200), outline_width=2)
        return y + text_h + params['section_spacing']

    def _render_feature(self, draw: ImageDraw.Draw, text: str, y: int, center_x: int, width: int, params: Dict[str, Any]) -> int:
        """渲染特色描述及其背景"""
        size, calculated_width = self.text_renderer.calculate_font_size_and_width(text, int(width * 0.8), max_size=40)
        font = self.text_renderer.load_font(size)
        text_w, text_h = self.text_renderer.get_text_size(text, font)
        
        bg_h = 50
        bg_w = min(text_w + 30, width)
        bg_x = center_x - bg_w // 2
        
        self.text_renderer.draw_rounded_rectangle(draw, (bg_x, y-5), (bg_w, bg_h), 20, fill=(50, 50, 50, 180))
        color = self._get_smart_feature_color()
        draw.text((center_x - text_w // 2, y), text, font=font, fill=color)
        return y + bg_h + params['section_spacing']

    def _render_info_section(self, draw, content, y, x, width, params, max_y):
        """渲染信息列表和价格区域"""
        info_texts = content.get("info_list", [])
        if not info_texts: return y

        # 为信息列表找到合适的字体
        longest_info_line = max([f"{item.get('title', '')}: {item.get('desc', '')}" for item in info_texts], key=len) if info_texts else ""
        info_size, _ = self.text_renderer.calculate_font_size_and_width(longest_info_line, int(width*0.55), max_size=30)
        info_font = self.text_renderer.load_font(info_size)
        _, line_h = self.text_renderer.get_text_size("T", info_font)

        # 为价格找到合适的字体
        price_text = f"¥{content.get('price', '')}"
        price_size, price_w = self.text_renderer.calculate_font_size_and_width(price_text, int(width*0.35), max_size=200, min_size=60)
        price_font = self.text_renderer.load_font(price_size)

        # 渲染信息列表
        for i, info in enumerate(info_texts):
            info_str = f"{info.get('title', '')}: {info.get('desc', '')}" if isinstance(info, dict) else str(info)
            draw.text((x, y + i * (line_h + params['line_spacing'])), info_str, font=info_font, fill=(255, 255, 255))
        
        # 渲染价格
        self.text_renderer.draw_text_with_shadow(draw, (x + width - price_w, y), price_text, price_font)

    # --- Color Extraction Logic (from demo) ---
    def _extract_dominant_color_edge(self, image: Image.Image) -> Tuple[int, int, int]:
        """从图像边缘提取主要颜色"""
        if image.mode != 'RGB': image = image.convert('RGB')
        w, h = image.size
        pixels = []
        edge_w = min(w, h) // 4
        
        points = [(x,y) for y in range(h) for x in range(w) if x<edge_w or x>w-edge_w or y<edge_w or y>h-edge_w]
        sample_points = random.sample(points, min(len(points), 200))
        
        for p in sample_points:
            pixel = image.getpixel(p)
            if sum(pixel) > 50 and sum(pixel) < 700:
                pixels.append(pixel)
        
        if not pixels: return (80, 120, 160)
        
        best_color = self._select_best_color(Counter(pixels).most_common(5))
        return self._adjust_color_for_background(best_color)

    def _select_best_color(self, candidates: List[Tuple[Tuple[int, int, int], int]]) -> Tuple[int, int, int]:
        """从候选颜色中选择最合适的"""
        best_score, best_color = -1, None
        for color, count in candidates:
            r,g,b = color
            brightness = (r*299 + g*587 + b*114) / 1000
            saturation = (max(r,g,b) - min(r,g,b)) / max(r,g,b) if max(r,g,b)>0 else 0
            
            b_score = 1.0 - abs((brightness - 130) / 130)
            s_score = 1.0 - abs(saturation - 0.5) / 0.5
            score = b_score * 0.4 + s_score * 0.6
            
            if score > best_score:
                best_score, best_color = score, color
        return best_color or candidates[0][0]

    def _adjust_color_for_background(self, color: Tuple[int, int, int]) -> Tuple[int, int, int]:
        """调整颜色使其更适合作为背景"""
        r, g, b = color
        h, s, v = colorsys.rgb_to_hsv(r/255.0, g/255.0, b/255.0)
        v = max(0.3, min(0.7, v)) # 限制亮度
        s = max(0.4, min(0.8, s)) # 限制饱和度
        r,g,b = [int(c*255) for c in colorsys.hsv_to_rgb(h,s,v)]
        return (r, g, b)

    def _ensure_colors_harmony(self, top: Tuple[int, int, int], bottom: Tuple[int, int, int]) -> Tuple[Tuple[int, int, int], Tuple[int, int, int]]:
        """确保颜色和谐"""
        dist = sum(abs(a-b) for a,b in zip(top,bottom))
        if dist < 30:
            factor = 1.1 if sum(top)/3 > 128 else 0.9
            top = tuple(max(0,min(255,int(c*factor))) for c in top)
        elif dist > 150:
            mid = tuple((a+b)//2 for a,b in zip(top,bottom))
            top = tuple(int(c*0.8+m*0.2) for c,m in zip(top,mid))
            bottom = tuple(int(c*0.8+m*0.2) for c,m in zip(bottom,mid))
        return top, bottom

    def _get_smart_feature_color(self) -> Tuple[int, int, int]:
        """为feature文本智能选择颜色"""
        if not self._current_background_colors: return (255, 255, 255)
        top, bottom = self._current_background_colors
        avg_bright = (sum(top)+sum(bottom))/6
        
        def get_tone(c):
            r,g,b=c
            return 'w' if r > g and r > b else ('f' if g > r and g > b else 'c')
        
        tone = get_tone(tuple((a+b)//2 for a,b in zip(top,bottom)))
        
        if avg_bright > 120:
            return {'c':(65,105,155), 'w':(155,85,65)}.get(tone, (85,125,85))
        else:
            return {'c':(135,185,235), 'w':(255,195,135)}.get(tone, (155,215,155))