#!/usr/bin/env python3
"""
Prompt converter: Stable Diffusion to Midjourney syntax
Converts SD-style prompts to Midjourney-compatible format.
"""

import re
import sys

def convert_sd_to_mj_prompt(sd_prompt: str) -> str:
    """
    Convert Stable Diffusion prompt to Midjourney syntax.

    Args:
        sd_prompt: The Stable Diffusion prompt string

    Returns:
        Midjourney-compatible prompt string
    """
    # Handle parentheses for emphasis (SD uses () while MJ uses ::)
    # In SD: (word) = 1.1 weight, ((word)) = 1.21 weight
    # In MJ: ::word = 1.0, ::word::0.5 = 0.5 weight

    # Convert emphasis parentheses to Midjourney's double colons
    result = sd_prompt

    # Handle negative prompts - move them after --no flag
    negative_match = re.search(r'\[(.*?)\]', result)
    negative_prompt = ""
    if negative_match:
        negative_prompt = negative_match.group(1)
        result = result[:negative_match.start()] + result[negative_match.end():]

    # Convert weight syntax: (word) -> ::word
    # This is a simplified conversion
    result = re.sub(r'\((.*?)\)', r'::\1', result)

    # Clean up multiple colons
    result = re.sub(r'::+', '::', result)

    # Add negative prompt as --no parameter
    if negative_prompt:
        result = f"{result} --no {negative_prompt.replace(', ', ',')}"

    return result.strip()

def convert_lora_reference(lora_string: str) -> str:
    """
    Convert Stable Diffusion LoRA references to Midjourney's style references.

    In SD: <lora:model_name:0.5>
    In MJ: Use --sref or --style parameters
    """
    lora_pattern = r'<lora:([^:]+):([0-9.]+)>'
    matches = re.findall(lora_pattern, lora_string)

    if not matches:
        return ""

    # For each LoRA, we'll create a style note
    # Midjourney doesn't have direct LoRA support but handles styles differently
    style_refs = []
    for name, weight in matches:
        style_refs.append(f"# LoRA '{name}' was weight {weight} in SD")

    return "\n".join(style_refs)

if __name__ == "__main__":
    # Example usage
    sd_example = "a beautiful landscape with mountains, (sunset:1.2), [ugly, deformed]"

    mj_prompt = convert_sd_to_mj_prompt(sd_example)
    print(f"SD Prompt: {sd_example}")
    print(f"MJ Prompt: {mj_prompt}")

#!/usr/bin/env python3
"""
Image processing equivalents: SD img2img -> Midjourney
Maps Stable Diffusion image-to-image workflows to Midjourney pan/zoom/vary.
"""

class ImageWorkflowMapper:
    """Maps SD image operations to Midjourney equivalents."""

    def __init__(self):
        self.operations = {
            "img2img": self.map_img2img,
            "inpainting": self.map_inpainting,
            "outpainting": self.map_outpainting,
            "upscale": self.map_upscale
        }

    def map_img2img(self, strength: float, prompt: str) -> str:
        """
        Convert SD img2img to Midjourney's --iw parameter.

        In SD: denoise strength (0.0-1.0)
        In MJ: --iw (0.0-2.0) - image weight
        """
        # Map SD strength to MJ image weight
        # Lower strength in SD = higher influence from original
        mj_iw = (1.0 - strength) * 2.0

        return f"{prompt} --iw {mj_iw:.2f}"

    def map_inpainting(self, mask_area: dict, prompt: str) -> str:
        """
        Convert SD inpainting to Midjourney.

        MJ doesn't have direct inpainting, use describe/blend instead.
        """
        # Use /describe to analyze the base image
        return f"# Use /describe command\n# Then /imagine with: {prompt}"

    def map_outpainting(self, direction: str, prompt: str) -> str:
        """
        Convert SD outpainting to Midjourney's pan operations.

        Directions: up, down, left, right
        """
        pan_map = {
            "up": "--pan up",
            "down": "--pan down",
            "left": "--pan left",
            "right": "--pan right"
        }

        pan_arg = pan_map.get(direction.lower(), "")
        return f"{prompt} {pan_arg}"

    def map_upscale(self, scale: int, prompt: str) -> str:
        """
        Convert SD upscaling to Midjourney's upscale options.

        MJ: --upbeta, --upalpha, --uplight
        """
        upscale_map = {
            2: "--upbeta",
            4: "--upalpha",
            1.5: "--uplight"
        }

        upscale_arg = upscale_map.get(scale, "--upbeta")
        return f"{prompt} {upscale_arg}"

# Example usage
if __name__ == "__main__":
    mapper = ImageWorkflowMapper()

    # Convert an img2img workflow
    sd_prompt = "a serene lake at sunset"
    sd_strength = 0.7

    mj_result = mapper.map_img2img(sd_strength, sd_prompt)
    print(f"SD: img2img with strength {sd_strength}")
    print(f"MJ: {mj_result}")

#!/usr/bin/env python3
"""
Workflow tracker for Midjourney jobs
Maintains local database of generated images and prompts.
"""

import json
from datetime import datetime
from pathlib import Path
from typing import Optional

class MJWorkflowTracker:
    """Tracks Midjourney generation history for workflow migration."""

    def __init__(self, db_path: str = "mj_workflow_db.json"):
        self.db_path = Path(db_path)
        self.data = self._load_database()

    def _load_database(self) -> dict:
        """Load existing database or create new one."""
        if self.db_path.exists():
            with open(self.db_path, 'r') as f:
                return json.load(f)
        return {"jobs": [], "prompts": []}

    def _save_database(self):
        """Persist database to disk."""
        with open(self.db_path, 'w') as f:
            json.dump(self.data, f, indent=2)

    def add_job(self, prompt: str, job_id: str,
                seed: Optional[int] = None,
                sd_source: Optional[str] = None):
        """
        Record a new Midjourney job.

        Args:
            prompt: The Midjourney prompt used
            job_id: Discord message ID for this job
            seed: The seed value if available
            sd_source: Original SD prompt if migrated
        """
        job_entry = {
            "job_id": job_id,
            "prompt": prompt,
            "seed": seed,
            "sd_source": sd_source,
            "timestamp": datetime.now().isoformat(),
            "status": "completed"
        }

        self.data["jobs"].append(job_entry)
        self._save_database()

    def find_similar(self, prompt: str, limit: int = 5):
        """Find similar prompts in history."""
        # Simple substring matching
        results = [
            job for job in self.data["jobs"]
            if prompt.lower() in job["prompt"].lower()
        ]
        return results[:limit]

    def export_prompts(self, output_file: str):
        """Export all prompts to a text file."""
        with open(output_file, 'w') as f:
            for job in self.data["jobs"]:
                f.write(f"{job['prompt']}\n")
                if job.get('sd_source'):
                    f.write(f"# From SD: {job['sd_source']}\n")
                f.write("\n")

# Usage example
if __name__ == "__main__":
    tracker = MJWorkflowTracker()

    # Add a migrated job
    tracker.add_job(
        prompt="a mountain landscape at sunset::1.2 --ar 16:9 --v 6",
        job_id="123456789012345678",
        seed=42,
        sd_source="a beautiful mountain landscape, sunset, highly detailed"
    )

    # Find similar prompts
    similar = tracker.find_similar("mountain landscape")
    print(f"Found {len(similar)} similar prompts")