# Canva API でバリエーションを一括生成 (擬似コード)
import canva_api
 
template_id = "DAF-xxxxx"  # テンプレートID
 
# CSV データから一括生成
products = [
    {"name": "プロダクトA", "price": "¥3,980", "image_url": "https://..."},
    {"name": "プロダクトB", "price": "¥5,480", "image_url": "https://..."},
    {"name": "プロダクトC", "price": "¥2,980", "image_url": "https://..."},
]
 
for product in products:
    design = canva_api.create_from_template(
        template_id=template_id,
        data={
            "product_name": product["name"],
            "price_text": product["price"],
            "product_image": product["image_url"],
        }
    )
    design.export(format="png", quality="high")
    print(f"生成完了: {product['name']}")

# Canva Brand Kit の自動設定とバリデーション
class CanvaBrandManager:
    """ブランド一貫性を維持するための管理クラス"""
 
    def __init__(self, api_key: str, brand_id: str):
        self.client = canva_api.Client(api_key=api_key)
        self.brand_id = brand_id
        self.brand_kit = None
 
    def load_brand_kit(self) -> dict:
        """ブランドキットを読み込み"""
        self.brand_kit = self.client.get_brand_kit(self.brand_id)
        return {
            "colors": {
                "primary": self.brand_kit.primary_color,
                "secondary": self.brand_kit.secondary_colors,
                "accent": self.brand_kit.accent_color,
            },
            "fonts": {
                "heading": self.brand_kit.heading_font,
                "body": self.brand_kit.body_font,
                "caption": self.brand_kit.caption_font,
            },
            "logos": [logo.url for logo in self.brand_kit.logos],
            "guidelines": self.brand_kit.guidelines_text,
        }
 
    def validate_design(self, design_id: str) -> dict:
        """デザインがブランドガイドラインに適合しているか検証"""
        design = self.client.get_design(design_id)
        issues = []
 
        # カラーチェック
        used_colors = design.get_used_colors()
        allowed_colors = set(self.brand_kit.all_colors)
        unauthorized = used_colors - allowed_colors
        if unauthorized:
            issues.append({
                "type": "color_violation",
                "severity": "warning",
                "detail": f"未承認カラー使用: {unauthorized}",
                "suggestion": f"許可カラー: {allowed_colors}"
            })
 
        # フォントチェック
        used_fonts = design.get_used_fonts()
        allowed_fonts = set(self.brand_kit.all_fonts)
        unauthorized_fonts = used_fonts - allowed_fonts
        if unauthorized_fonts:
            issues.append({
                "type": "font_violation",
                "severity": "error",
                "detail": f"未承認フォント使用: {unauthorized_fonts}",
                "suggestion": f"許可フォント: {allowed_fonts}"
            })
 
        # ロゴ配置チェック
        logo_placements = design.get_logo_placements()
        for placement in logo_placements:
            if placement.clear_space < self.brand_kit.min_clear_space:
                issues.append({
                    "type": "logo_clearspace",
                    "severity": "error",
                    "detail": f"ロゴの余白不足: {placement.clear_space}px",
                    "suggestion": f"最小余白: {self.brand_kit.min_clear_space}px"
                })
 
        return {
            "is_compliant": len([i for i in issues if i["severity"] == "error"]) == 0,
            "issues": issues,
            "score": max(0, 100 - len(issues) * 15),
        }
 
    def batch_generate_with_brand(
        self,
        template_id: str,
        data_list: list[dict],
        output_formats: list[str] = ["png"],
        sizes: list[str] = None,
    ) -> list[dict]:
        """ブランドキット適用済みの一括生成"""
        results = []
        for data in data_list:
            design = self.client.create_from_template(
                template_id=template_id,
                data=data,
                brand_kit_id=self.brand_id,  # ブランドキット自動適用
            )
 
            # バリデーション
            validation = self.validate_design(design.id)
            if not validation["is_compliant"]:
                # 自動修正を試行
                design = self._auto_fix_brand_issues(design, validation["issues"])
 
            # 複数サイズで書き出し
            exports = []
            target_sizes = sizes or ["instagram_post", "facebook_post", "twitter_post"]
            for size in target_sizes:
                for fmt in output_formats:
                    export = design.export(
                        format=fmt,
                        size_preset=size,
                        quality="high"
                    )
                    exports.append({
                        "size": size,
                        "format": fmt,
                        "url": export.url,
                    })
 
            results.append({
                "design_id": design.id,
                "data": data,
                "validation": validation,
                "exports": exports,
            })
 
        return results
 
    def _auto_fix_brand_issues(self, design, issues):
        """ブランド違反の自動修正"""
        for issue in issues:
            if issue["type"] == "color_violation":
                # 最も近いブランドカラーに置換
                design.replace_colors_to_nearest_brand()
            elif issue["type"] == "font_violation":
                # ブランドフォントに置換
                design.replace_fonts_to_brand()
        return design
 
 
# 使用例
brand_mgr = CanvaBrandManager(
    api_key="your-api-key",
    brand_id="brand-123"
)
 
brand_mgr.load_brand_kit()
 
# SNS投稿の一括生成
products_data = [
    {"title": "春の新作コレクション", "subtitle": "2026 Spring", "image": "spring.jpg"},
    {"title": "サマーセール開催中", "subtitle": "最大50%OFF", "image": "summer.jpg"},
    {"title": "秋の限定アイテム", "subtitle": "数量限定", "image": "autumn.jpg"},
]
 
results = brand_mgr.batch_generate_with_brand(
    template_id="template-456",
    data_list=products_data,
    output_formats=["png", "jpg"],
    sizes=["instagram_post", "instagram_story", "facebook_cover"],
)
 
for r in results:
    print(f"デザイン {r['design_id']}: スコア={r['validation']['score']}")
    for export in r["exports"]:
        print(f"  {export['size']} ({export['format']}): {export['url']}")

# Adobe Firefly API (擬似コード)
import adobe_firefly
 
client = adobe_firefly.Client(api_key="your-api-key")
 
# Text to Image
result = client.generate_image(
    prompt="modern office workspace, clean desk, laptop, indoor plant, "
           "natural light from large window, minimalist style",
    style="photo",
    aspect_ratio="16:9",
    content_class="photo",        # photo / art
    visual_intensity=4,            # 1-10
    negative_prompt="cluttered, dark, messy",
    num_variations=4,
)
 
for i, image in enumerate(result.images):
    image.save(f"workspace_v{i+1}.png")
 
# Generative Fill
result = client.generative_fill(
    image_path="product.jpg",
    mask_path="mask.png",          # 白=生成領域、黒=保持領域
    prompt="wooden table surface with soft shadows",
)
result.image.save("product_on_wood.jpg")

# Adobe Creative Cloud 統合ワークフロー
class AdobeCreativeWorkflow:
    """Firefly + Photoshop + Illustrator の統合パイプライン"""
 
    def __init__(self, client_id: str, client_secret: str):
        self.auth = self._authenticate(client_id, client_secret)
        self.firefly = FireflyClient(self.auth)
        self.photoshop = PhotoshopAPIClient(self.auth)
        self.illustrator = IllustratorAPIClient(self.auth)
 
    def _authenticate(self, client_id, client_secret):
        """Adobe IMS OAuth認証"""
        import requests
        response = requests.post(
            "https://ims-na1.adobelogin.com/ims/token/v3",
            data={
                "grant_type": "client_credentials",
                "client_id": client_id,
                "client_secret": client_secret,
                "scope": "openid,creative_sdk,firefly_api",
            }
        )
        return response.json()["access_token"]
 
    def generate_product_hero(
        self,
        product_image_path: str,
        scene_prompt: str,
        output_sizes: dict = None,
    ) -> dict:
        """商品ヒーロー画像の生成パイプライン
 
        1. 商品画像の背景除去
        2. Firefly でシーン生成
        3. Photoshop で合成・レタッチ
        4. 複数サイズで書き出し
        """
        # Step 1: 背景除去
        cutout = self.photoshop.remove_background(
            input_path=product_image_path,
            output_format="png",
            refine_edge=True,      # エッジの精密処理
            edge_feather=1.5,      # 自然なフェザリング
        )
 
        # Step 2: シーン背景を Firefly で生成
        background = self.firefly.generate_image(
            prompt=scene_prompt,
            style="photo",
            aspect_ratio="16:9",
            content_class="photo",
            visual_intensity=5,
            num_variations=4,       # 4パターン生成
        )
 
        # Step 3: Photoshop API で合成
        composites = []
        for i, bg in enumerate(background.images):
            composite = self.photoshop.composite_images(
                layers=[
                    {"type": "background", "image": bg.url},
                    {
                        "type": "foreground",
                        "image": cutout.url,
                        "position": "center",
                        "scale": 0.6,
                        "shadow": {
                            "type": "drop",
                            "opacity": 30,
                            "angle": 135,
                            "distance": 15,
                            "blur": 25,
                        },
                    },
                ],
                adjustments=[
                    {"type": "color_match", "reference": "background"},
                    {"type": "lighting_match", "intensity": 0.7},
                ],
            )
            composites.append(composite)
 
        # Step 4: 複数サイズで書き出し
        sizes = output_sizes or {
            "hero_desktop": {"width": 1920, "height": 1080},
            "hero_mobile": {"width": 750, "height": 1334},
            "thumbnail": {"width": 400, "height": 400},
            "og_image": {"width": 1200, "height": 630},
        }
 
        final_outputs = {}
        best_composite = composites[0]  # または手動選択
 
        for name, size in sizes.items():
            output = self.photoshop.resize_and_crop(
                image=best_composite.url,
                width=size["width"],
                height=size["height"],
                crop_mode="smart",   # AI による最適クロップ
                format="jpg",
                quality=92,
            )
            final_outputs[name] = output.url
 
        return {
            "variations": [c.url for c in composites],
            "final_outputs": final_outputs,
        }
 
    def batch_style_transfer(
        self,
        source_images: list[str],
        style_reference: str,
        strength: float = 0.7,
    ) -> list[str]:
        """Style Reference を使ったバッチスタイル統一
 
        ブランドの写真すべてを同じトーンに統一する
        """
        results = []
        for img_path in source_images:
            result = self.firefly.style_transfer(
                source_image=img_path,
                style_reference=style_reference,
                strength=strength,
                preserve_structure=True,    # 構図を保持
                preserve_color_range=0.3,   # 色の変更範囲
            )
            results.append(result.url)
        return results
 
 
# 使用例: ECサイトの商品画像制作
workflow = AdobeCreativeWorkflow(
    client_id="your-client-id",
    client_secret="your-client-secret"
)
 
# 商品ヒーロー画像生成
hero = workflow.generate_product_hero(
    product_image_path="product_sneaker.jpg",
    scene_prompt="urban street at golden hour, wet asphalt reflection, "
                 "cinematic lighting, shallow depth of field, warm tones",
    output_sizes={
        "banner": {"width": 1920, "height": 600},
        "square": {"width": 1080, "height": 1080},
        "story": {"width": 1080, "height": 1920},
    }
)
 
print(f"バリエーション: {len(hero['variations'])}個生成")
for name, url in hero["final_outputs"].items():
    print(f"  {name}: {url}")

# Figma API でデザインデータを取得・操作
import requests
import json
 
class FigmaDesignAutomation:
    """Figma API を使ったデザインプロセス自動化"""
 
    BASE_URL = "https://api.figma.com/v1"
 
    def __init__(self, access_token: str):
        self.headers = {"X-FIGMA-TOKEN": access_token}
 
    def get_file(self, file_key: str, depth: int = 2) -> dict:
        """Figma ファイルの構造を取得"""
        response = requests.get(
            f"{self.BASE_URL}/files/{file_key}",
            headers=self.headers,
            params={"depth": depth}
        )
        response.raise_for_status()
        return response.json()
 
    def get_components(self, file_key: str) -> list[dict]:
        """ファイル内のコンポーネント一覧を取得"""
        response = requests.get(
            f"{self.BASE_URL}/files/{file_key}/components",
            headers=self.headers,
        )
        data = response.json()
        return [
            {
                "key": comp["key"],
                "name": comp["name"],
                "description": comp.get("description", ""),
                "containing_frame": comp.get("containing_frame", {}).get("name", ""),
            }
            for comp in data.get("meta", {}).get("components", [])
        ]
 
    def get_design_tokens(self, file_key: str) -> dict:
        """デザイントークン（Variables）を取得"""
        response = requests.get(
            f"{self.BASE_URL}/files/{file_key}/variables/local",
            headers=self.headers,
        )
        data = response.json()
 
        tokens = {"colors": {}, "spacing": {}, "typography": {}}
        for var_id, var in data.get("meta", {}).get("variables", {}).items():
            name = var["name"]
            resolved = var.get("resolvedType", "")
            values = var.get("valuesByMode", {})
 
            if resolved == "COLOR":
                # RGBA値を取得
                for mode_id, value in values.items():
                    if isinstance(value, dict) and "r" in value:
                        hex_color = self._rgba_to_hex(value)
                        tokens["colors"][name] = hex_color
            elif resolved == "FLOAT":
                for mode_id, value in values.items():
                    tokens["spacing"][name] = value
 
        return tokens
 
    def export_components_as_svg(
        self,
        file_key: str,
        node_ids: list[str],
        output_dir: str = "./exports",
    ) -> list[str]:
        """コンポーネントをSVGとしてエクスポート"""
        import os
        os.makedirs(output_dir, exist_ok=True)
 
        ids_param = ",".join(node_ids)
        response = requests.get(
            f"{self.BASE_URL}/images/{file_key}",
            headers=self.headers,
            params={
                "ids": ids_param,
                "format": "svg",
                "svg_include_id": True,
                "svg_simplify_stroke": True,
            }
        )
        data = response.json()
 
        exported = []
        for node_id, url in data.get("images", {}).items():
            if url:
                svg_response = requests.get(url)
                filename = f"{output_dir}/{node_id.replace(':', '-')}.svg"
                with open(filename, "w") as f:
                    f.write(svg_response.text)
                exported.append(filename)
 
        return exported
 
    def generate_design_audit_report(self, file_key: str) -> dict:
        """デザインファイルの品質監査レポートを生成"""
        file_data = self.get_file(file_key, depth=4)
        components = self.get_components(file_key)
 
        # ページ分析
        pages = file_data.get("document", {}).get("children", [])
        report = {
            "file_name": file_data.get("name", "Unknown"),
            "pages": len(pages),
            "components_count": len(components),
            "issues": [],
            "recommendations": [],
        }
 
        # コンポーネント使用状況の分析
        detached_instances = 0
        unnamed_layers = 0
        inconsistent_spacing = set()
 
        for page in pages:
            self._analyze_node(
                page, report, detached_instances,
                unnamed_layers, inconsistent_spacing
            )
 
        # レポート生成
        if unnamed_layers > 10:
            report["issues"].append({
                "type": "naming",
                "severity": "warning",
                "message": f"{unnamed_layers}個の命名されていないレイヤーがあります",
                "fix": "レイヤーに意味のある名前を付けてください",
            })
 
        if detached_instances > 0:
            report["issues"].append({
                "type": "consistency",
                "severity": "error",
                "message": f"{detached_instances}個のデタッチされたインスタンスがあります",
                "fix": "メインコンポーネントに再リンクしてください",
            })
 
        report["score"] = max(0, 100 - len(report["issues"]) * 10)
        return report
 
    def _rgba_to_hex(self, rgba: dict) -> str:
        """RGBA値を16進カラーコードに変換"""
        r = int(rgba["r"] * 255)
        g = int(rgba["g"] * 255)
        b = int(rgba["b"] * 255)
        return f"#{r:02x}{g:02x}{b:02x}"
 
    def _analyze_node(self, node, report, detached, unnamed, spacing):
        """ノードを再帰的に分析"""
        if node.get("name", "").startswith("Frame ") or node.get("name", "").startswith("Group "):
            unnamed += 1
        children = node.get("children", [])
        for child in children:
            self._analyze_node(child, report, detached, unnamed, spacing)
 
 
# 使用例
figma = FigmaDesignAutomation(access_token="your-figma-token")
 
# デザイントークンの取得
tokens = figma.get_design_tokens(file_key="abc123xyz")
print("カラートークン:")
for name, color in tokens["colors"].items():
    print(f"  {name}: {color}")
 
# 品質監査レポート
report = figma.generate_design_audit_report(file_key="abc123xyz")
print(f"\nデザイン監査スコア: {report['score']}/100")
for issue in report["issues"]:
    print(f"  [{issue['severity']}] {issue['message']}")

# 複数ツールを連携させた制作パイプライン
class DesignPipeline:
    """Canva + Firefly + Figma の統合パイプライン"""
 
    def __init__(self, config: dict):
        self.canva = CanvaBrandManager(
            api_key=config["canva_api_key"],
            brand_id=config["canva_brand_id"],
        )
        self.adobe = AdobeCreativeWorkflow(
            client_id=config["adobe_client_id"],
            client_secret=config["adobe_client_secret"],
        )
        self.figma = FigmaDesignAutomation(
            access_token=config["figma_token"],
        )
 
    def product_launch_campaign(
        self,
        product_name: str,
        product_images: list[str],
        brand_guidelines: dict,
    ) -> dict:
        """製品ローンチキャンペーンの全デザイン素材を一括生成
 
        1. Firefly で高品質商品画像を生成
        2. Canva でSNS投稿素材を一括生成
        3. Figma のデザインシステムから LP コンポーネントを取得
        """
        results = {"hero_images": [], "sns_assets": [], "lp_components": []}
 
        # Phase 1: 商品ヒーロー画像（Adobe Firefly）
        for img in product_images:
            hero = self.adobe.generate_product_hero(
                product_image_path=img,
                scene_prompt=brand_guidelines.get(
                    "hero_scene",
                    "clean minimalist studio, soft lighting"
                ),
            )
            results["hero_images"].append(hero)
 
        # Phase 2: SNS 素材（Canva）
        sns_data = []
        for i, hero in enumerate(results["hero_images"]):
            sns_data.append({
                "product_name": product_name,
                "hero_image": hero["final_outputs"]["square"],
                "campaign_text": f"{product_name} 新発売",
                "cta_text": "詳しくはプロフィールのリンクから",
            })
 
        results["sns_assets"] = self.canva.batch_generate_with_brand(
            template_id=brand_guidelines["sns_template_id"],
            data_list=sns_data,
            sizes=["instagram_post", "instagram_story",
                   "facebook_post", "twitter_post"],
        )
 
        # Phase 3: LP コンポーネント（Figma）
        components = self.figma.get_components(
            file_key=brand_guidelines["figma_file_key"]
        )
        lp_components = [
            c for c in components
            if "product" in c["name"].lower() or "hero" in c["name"].lower()
        ]
        results["lp_components"] = lp_components
 
        return results
 
 
# パイプライン実行
pipeline = DesignPipeline(config={
    "canva_api_key": "canva-key",
    "canva_brand_id": "brand-123",
    "adobe_client_id": "adobe-id",
    "adobe_client_secret": "adobe-secret",
    "figma_token": "figma-token",
})
 
campaign = pipeline.product_launch_campaign(
    product_name="EcoBreeze スニーカー",
    product_images=["sneaker_front.jpg", "sneaker_side.jpg"],
    brand_guidelines={
        "hero_scene": "urban rooftop at sunset, concrete and plants",
        "sns_template_id": "template-789",
        "figma_file_key": "xyz789abc",
    },
)
 
print(f"ヒーロー画像: {len(campaign['hero_images'])}パターン")
print(f"SNS素材: {len(campaign['sns_assets'])}セット")
print(f"LPコンポーネント: {len(campaign['lp_components'])}個")

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()