#!/usr/bin/env python3
"""Small media requests for Antigravity Manager. Python 3.9+, standard library only."""
import argparse
import base64
import getpass
import json
import os
from pathlib import Path
import tempfile
import urllib.error
import urllib.parse
import urllib.request
import uuid


class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None


def read_media(filename, kind):
    path = Path(filename)
    extensions = {
        'image': {'.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp'},
        'audio': {'.mp3': 'audio/mp3', '.wav': 'audio/wav', '.m4a': 'audio/aac', '.ogg': 'audio/ogg', '.flac': 'audio/flac', '.aif': 'audio/aiff', '.aiff': 'audio/aiff'},
        'video': {'.mp4': 'video/mp4', '.webm': 'video/webm', '.mov': 'video/quicktime'},
    }
    mime = extensions[kind].get(path.suffix.lower())
    if mime is None:
        raise ValueError('Choose a supported ' + kind + ' file extension.')
    # This example deliberately uses small files; these are helper limits.
    limit = (15 if kind == 'audio' else 20) * 1024 * 1024
    with path.open('rb') as f:
        data = f.read(limit + 1)
    if not data or len(data) > limit:
        raise ValueError(f'Use a nonempty {kind} file at most {limit // (1024 * 1024)} MiB for this example.')
    return mime, data


def multipart(fields, files):
    boundary = 'manager-media-' + uuid.uuid4().hex
    chunks = []
    for name, value in fields.items():
        chunks.append(f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"\r\n\r\n'.encode() + str(value).encode() + b'\r\n')
    for name, filename, mime, data in files:
        # Generated ASCII filenames avoid disclosing the user's local path.
        chunks.append(f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"; filename="{filename}"\r\nContent-Type: {mime}\r\n\r\n'.encode() + data + b'\r\n')
    chunks.append(f'--{boundary}--\r\n'.encode())
    return b''.join(chunks), 'multipart/form-data; boundary=' + boundary


def build_request(args):
    task = args.task
    if task == 'generate':
        if args.file:
            raise ValueError('Use edit to supply reference images.')
        body = {'model': args.model, 'prompt': args.prompt, 'size': args.size,
                'image_size': args.image_size, 'n': 1, 'response_format': 'url'}
        return '/v1/images/generations', json.dumps(body).encode(), 'application/json'
    if task in ('edit', 'transcribe'):
        if not args.file or (task == 'transcribe' and len(args.file) != 1):
            raise ValueError('Use --file once for transcription, or once per edit reference.')
        kind = 'image' if task == 'edit' else 'audio'
        files = []
        for i, filename in enumerate(args.file, 1):
            mime, data = read_media(filename, kind)
            name = f'image{i}' if task == 'edit' else 'file'
            files.append((name, f'input-{i}' + Path(filename).suffix.lower(), mime, data))
        if task == 'edit' and sum(len(x[3]) for x in files) > 32 * 1024 * 1024:
            raise ValueError('Keep edit references within 32 MiB total for this example.')
        fields = {'model': args.model, 'prompt': args.prompt}
        if task == 'edit':
            fields.update(aspect_ratio=args.size, image_size=args.image_size, n='1', response_format='url')
        body, content_type = multipart(fields, files)
        return ('/v1/images/edits' if task == 'edit' else '/v1/audio/transcriptions'), body, content_type
    if len(args.file) != 1:
        raise ValueError('Use --file exactly once for image, audio or video analysis.')
    mime, data = read_media(args.file[0], task)
    encoded = base64.b64encode(data).decode('ascii')
    if task == 'audio':
        block = {'type': 'input_audio', 'input_audio': {'data': encoded, 'format': mime}}
    else:
        key = task + '_url'
        block = {'type': key, key: {'url': f'data:{mime};base64,{encoded}'}}
        if task == 'video':
            block[key]['mime_type'] = mime
    body = {'model': args.model, 'stream': False, 'messages': [
        {'role': 'user', 'content': [{'type': 'text', 'text': args.prompt}, block]}]}
    return '/v1/chat/completions', json.dumps(body).encode(), 'application/json'


def save_result(task, result, folder):
    if not isinstance(result, dict):
        raise ValueError('Expected a JSON object. Inspect response.json.')
    if task in ('generate', 'edit'):
        images = result.get('data')
        if not isinstance(images, list) or not images:
            raise ValueError('The response contains no images. Inspect response.json.')
        for i, item in enumerate(images, 1):
            if not isinstance(item, dict) or not isinstance(item.get('url'), str):
                raise ValueError('Expected an inline image data URL. Inspect response.json.')
            url = item['url']
            header, sep, encoded = url.partition(',')
            extensions = {'data:image/png;base64': '.png', 'data:image/jpeg;base64': '.jpg', 'data:image/webp;base64': '.webp', 'data:image/gif;base64': '.gif'}
            ext = extensions.get(header)
            if not sep or ext is None:
                raise ValueError('Expected an inline image data URL. Inspect response.json.')
            data = base64.b64decode(encoded, validate=True)
            if not data:
                raise ValueError('The returned image is empty. Inspect response.json.')
            with (folder / f'image-{i}{ext}').open('xb') as f:
                f.write(data)
        return
    if task == 'transcribe':
        text = result.get('text')
    else:
        choices = result.get('choices')
        if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict):
            raise ValueError('The response contains no answer. Inspect response.json.')
        message = choices[0].get('message')
        text = message.get('content') if isinstance(message, dict) else None
    if not isinstance(text, str) or not text.strip():
        raise ValueError('The response contains no text answer. Inspect response.json.')
    (folder / ('transcript.txt' if task == 'transcribe' else 'answer.txt')).write_text(text, encoding='utf-8')


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('task', choices=['generate', 'edit', 'image', 'transcribe', 'audio', 'video'])
    parser.add_argument('--model', required=True, help='Exact model ID available to your account for this task')
    parser.add_argument('--prompt', required=True)
    parser.add_argument('--file', action='append', default=[], help='Local input; repeat for edit references')
    parser.add_argument('--base-url', default='http://127.0.0.1:8045', help='Manager origin, without /v1')
    parser.add_argument('--size', default='16:9', choices=['1:1','16:9','9:16','4:3','3:4','3:2','2:3','21:9','5:4','4:5'])
    parser.add_argument('--image-size', default='1K', choices=['1K','2K','4K'])
    args = parser.parse_args()
    base = urllib.parse.urlsplit(args.base_url)
    if base.scheme not in ('http', 'https') or not base.netloc or base.username or base.password or base.path not in ('', '/') or base.query or base.fragment:
        parser.error('--base-url must be an http(s) origin without credentials, path, query or fragment.')
    folder = None
    try:
        endpoint, body, content_type = build_request(args)
        key = os.environ.get('ANTIGRAVITY_API_KEY') or getpass.getpass('Manager API key (hidden): ')
        if not key.strip():
            raise ValueError('An API key is required.')
        request = urllib.request.Request(args.base_url.rstrip('/') + endpoint, data=body,
            headers={'Authorization': 'Bearer ' + key, 'Content-Type': content_type})
        folder = Path(tempfile.mkdtemp(prefix='media-result-', dir='.'))
        print('Results:', folder.resolve())
        try:
            with urllib.request.build_opener(NoRedirect).open(request, timeout=180) as response:
                raw = response.read()
        except urllib.error.HTTPError as error:
            (folder / 'error-response.txt').write_bytes(error.read())
            raise ValueError(f'HTTP {error.code}. Inspect error-response.txt privately.') from error
        (folder / 'response.json').write_bytes(raw)
        save_result(args.task, json.loads(raw), folder)
        print('Saved. Open the output and check that it answers your request.')
    except (OSError, ValueError, KeyError, IndexError, TypeError, urllib.error.URLError) as error:
        parser.exit(1, str(error) + '\n')


if __name__ == '__main__':
    main()
