# Glossi Uploader for CLO 3D — single-file build v0.1.3
# Generated by scripts/package_clo.py — do not edit; edit the repo sources.
# Register via: Plugin tab > Plug-in Manager > + ADD > this file.
import base64 as _b64
import sys as _sys
import types as _types

glossi_client = _types.ModuleType("glossi_client")
exec(_b64.b64decode(""""Glossi REST client shared by all DCC exporter plugins (Max, Blender, CLO).

Standard library only (urllib) so it runs unmodified in every host app's
embedded Python (3ds Max ships CPython without `requests`; Blender and CLO
bundle their own interpreters). Python 3.7+ compatible.

This file is the single source of truth in `shared/`. Plugins ship a vendored
copy created by `scripts/sync_client.py`; CI fails if a copy drifts. Edit the
`shared/` copy only.

Typical plugin usage:

    from . import glossi_client

    info = glossi_client.validate_key(api_key)          # -> workspace name
    model = glossi_client.upload_model(
        "/path/to/export.glb", api_key,
        name="My Product", progress=print,
    )                                                    # blocks until READY
"""

import http.client
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request

__version__ = "0.1.3"

DEFAULT_BASE_URL = "https://api.glossi.io/api/v1"

# Content types for the S3 PUT. Anything not listed uploads as octet-stream;
# the backend keys processing off the file extension, not the content type.
_CONTENT_TYPES = {
    "glb": "model/gltf-binary",
    "gltf": "model/gltf+json",
    "usd": "model/vnd.usd",
    "usdz": "model/vnd.usdz+zip",
    "fbx": "application/octet-stream",
    "obj": "application/octet-stream",
}

# About four minutes in all: giving up discards every part sent, so this has to outlast
# a network change. A failed part is resent alone.
_RETRY_DELAYS_SECONDS = (2, 5, 15, 30, 60, 60, 60)
_ATTEMPTS = len(_RETRY_DELAYS_SECONDS) + 1
_MAX_RETRY_AFTER_SECONDS = 120
_PART_TIMEOUT_SECONDS = 600
# S3 assembling several GB can take far longer than an ordinary API call.
_COMPLETE_TIMEOUT_SECONDS = 300

_USER_AGENT = "glossi-exporter-tools/%s python/%s" % (
    __version__,
    ".".join(str(v) for v in sys.version_info[:3]),
)


class GlossiApiError(Exception):
    """Any failure talking to the Glossi API.

    `code` is the API's machine-readable error code (e.g. "INVALID_API_KEY",
    "PLAN_LIMIT_REACHED", "FILE_NOT_UPLOADED") or None for transport-level
    failures. `http_status` is the HTTP status or None. `transient` means the
    same request may work if sent again. `retry_after` is the server's requested
    wait in seconds, or None.
    """

    def __init__(self, message, code=None, http_status=None, retry_after=None):
        super(GlossiApiError, self).__init__(message)
        self.code = code
        self.http_status = http_status
        self.retry_after = retry_after
        self.transient = http_status is None or http_status >= 500 or http_status in (408, 429)


class GlossiFileError(GlossiApiError):
    """The local file could not be read, so retrying the request won't help."""

    def __init__(self, message):
        super(GlossiFileError, self).__init__(message)
        self.transient = False


# Whether this interpreter's urllib can speak HTTPS. Some host apps embed a
# Python with a broken/missing ssl module (e.g. KeyShot on macOS resolves its
# stdlib against a wrong-architecture _ssl) — urllib then rejects https URLs
# outright ("unknown url type: https"). Cached on first use.
_HTTPS_SUPPORTED = None


def _https_supported():
    global _HTTPS_SUPPORTED
    if _HTTPS_SUPPORTED is None:
        try:
            import ssl  # noqa: F401
            _HTTPS_SUPPORTED = True
        except ImportError:
            _HTTPS_SUPPORTED = False
    return _HTTPS_SUPPORTED


class _FileSlice(object):
    """File-like view of one byte range, so urllib streams it from disk."""

    def __init__(self, path, offset, length):
        self._path = path
        try:
            self._file = open(path, "rb")
            self._file.seek(offset)
        except OSError as exc:
            raise GlossiFileError("cannot read %s: %s" % (path, exc))
        self._remaining = length
        self.length = length

    def read(self, size=-1):
        if size is None or size < 0 or size > self._remaining:
            size = self._remaining
        try:
            chunk = self._file.read(size)
        except OSError as exc:
            raise GlossiFileError("cannot read %s: %s" % (self._path, exc))
        if size and not chunk:
            raise GlossiFileError("%s got shorter during the upload" % self._path)
        self._remaining -= len(chunk)
        return chunk

    def close(self):
        self._file.close()


def _parse_retry_after(value):
    try:
        return float(value)
    except (TypeError, ValueError):
        return None  # absent, or the HTTP-date form


def _parse_body(body):
    if not body:
        return {}
    try:
        return json.loads(body.decode("utf-8"))
    except ValueError:  # e.g. a captive portal's HTML page, sent with a 200
        raise GlossiApiError("network error: the response from the server was not JSON")


def _error_from_response(status, detail, retry_after=None):
    code = None
    try:
        err = json.loads(detail)["error"]
        code = err.get("code")
        detail = "%s: %s" % (code, err.get("message"))
    except Exception:
        pass
    return GlossiApiError("HTTP %s - %s" % (status, detail),
                          code=code, http_status=status, retry_after=retry_after)


def _request(method, url, api_key=None, json_body=None, raw_body=None,
             content_type=None, timeout=60):
    headers = {"User-Agent": _USER_AGENT}
    if api_key:
        headers["X-API-Key"] = api_key
    data = None
    if json_body is not None:
        data = json.dumps(json_body).encode("utf-8")
        headers["Content-Type"] = "application/json"
    elif raw_body is not None:
        data = raw_body
        if isinstance(raw_body, _FileSlice):
            headers["Content-Length"] = str(raw_body.length)
        if content_type:
            headers["Content-Type"] = content_type
    if url.startswith("https") and not _https_supported():
        return _request_curl(method, url, headers, data, timeout)
    return _request_urllib(method, url, headers, data, timeout)


def _request_urllib(method, url, headers, data, timeout):
    req = urllib.request.Request(url, data=data, headers=headers, method=method)
    try:
        try:
            with urllib.request.urlopen(req, timeout=timeout) as resp:
                return _parse_body(resp.read())
        except urllib.error.HTTPError as exc:
            raise _error_from_response(
                exc.code, exc.read().decode("utf-8", "replace"),
                _parse_retry_after((exc.headers or {}).get("Retry-After")))
    except urllib.error.URLError as exc:
        raise GlossiApiError("network error: %s" % exc.reason)
    # A drop mid-response is raw, not a URLError, and the plugins' workers only catch ours.
    except (OSError, http.client.HTTPException) as exc:
        raise GlossiApiError("network error: %s" % exc)


def _request_curl(method, url, headers, data, timeout):
    """Fallback transport via the curl binary (ships with macOS and
    Windows 10+), for interpreters whose ssl module is unusable. Bodies go
    over stdin, so uploads never hit argv limits; the status code is appended
    to stdout after a newline we add ourselves."""
    if isinstance(data, _FileSlice):
        # In memory on this path: one part, or the whole file on an API without parts.
        data = data.read()
    args = ["curl", "--silent", "--show-error", "--request", method,
            "--max-time", str(int(timeout)),
            "--write-out", "\\n%{http_code}", url]
    for name, value in headers.items():
        args += ["--header", "%s: %s" % (name, value)]
    if data is not None:
        args += ["--data-binary", "@-"]
    try:
        proc = subprocess.run(args, input=data, capture_output=True)
    except OSError as exc:
        raise GlossiApiError(
            "network error: this app's Python cannot use https and curl is "
            "unavailable (%s)" % exc)
    if proc.returncode != 0:
        raise GlossiApiError("network error: %s"
                             % proc.stderr.decode("utf-8", "replace").strip())
    body, _, status_str = proc.stdout.rpartition(b"\n")
    try:
        status = int(status_str)
    except ValueError:
        raise GlossiApiError("network error: unexpected curl output %r"
                             % proc.stdout[-40:])
    if status >= 400:
        raise _error_from_response(status, body.decode("utf-8", "replace"))
    return _parse_body(body)


def resolve_base_url(app_name):
    """The API base URL a plugin should use.

    Production is baked in (DEFAULT_BASE_URL); normal users never configure
    this. For dev/testing only, it can be overridden — precedence:
    GLOSSI_BASE_URL env var > "base_url" in the app's config file > prod.
    Set/clear overrides with scripts/dev_override.py.
    """
    env = os.environ.get("GLOSSI_BASE_URL")
    if env:
        return env.strip().rstrip("/")
    configured = load_config(app_name).get("base_url")
    if configured:
        return configured.strip().rstrip("/")
    return DEFAULT_BASE_URL


def validate_key(api_key, base_url=DEFAULT_BASE_URL):
    """Check an API key and identify its workspace via GET /me.

    Returns the response dict, e.g.
    {"workspace": {"id": "...", "name": "..."}, "apiKey": {"name": "...", ...}}.
    Raises GlossiApiError (code "INVALID_API_KEY", http_status 401) on a bad key.
    """
    return _request("GET", base_url + "/me", api_key=api_key)


def file_type_for(path):
    """Bare lowercase extension the API expects as fileType ("glb", "fbx", ...)."""
    ext = os.path.splitext(path)[1]
    return ext.lstrip(".").lower()


def _put_slice(path, offset, length, url, content_type=None):
    body = _FileSlice(path, offset, length)
    try:
        # The signed URL carries its own auth -- no API key on this request.
        _request("PUT", url, raw_body=body, content_type=content_type,
                 timeout=_PART_TIMEOUT_SECONDS)
    finally:
        body.close()


def _file_stamp(path):
    try:
        info = os.stat(path)
    except OSError as exc:
        raise GlossiFileError("cannot read %s: %s" % (path, exc))
    return info.st_size, info.st_mtime_ns


def _check_unchanged(path, stamp):
    # Parts are read over a long upload, so a rewrite would mix versions or cut the file short.
    if _file_stamp(path) != stamp:
        raise GlossiFileError("%s changed during the upload" % path)


def _retry_delay(delay, exc):
    return max(delay, min(exc.retry_after or 0, _MAX_RETRY_AFTER_SECONDS))


def _with_retries(call, say, message):
    for delay in _RETRY_DELAYS_SECONDS:
        try:
            return call()
        except GlossiApiError as exc:
            if not exc.transient:
                raise
            say(message)
            time.sleep(_retry_delay(delay, exc))
    return call()


def _upload_parts(path, api_key, model_url, stamp, say):
    """Send the file to S3 in parts. Returns False if the API predates them."""
    file_size = stamp[0]
    try:
        state = _request("POST", model_url + "/multipart", api_key=api_key,
                         json_body={"fileSize": file_size})
    except GlossiApiError as exc:
        # An unknown route has no error code; a known 404 (no such model) does.
        if exc.http_status == 404 and exc.code is None:
            return False
        raise
    if state.get("alreadyUploaded"):
        return True

    part_size = state["partSize"]
    part_count = state["partCount"]
    held = set(p["partNumber"] for p in state.get("parts") or [])
    complete_unclear = False

    def send_part(number):
        _check_unchanged(path, stamp)
        offset = (number - 1) * part_size
        # Signed per attempt: a slow part can outlive its URL's hour.
        signed = _request("POST", model_url + "/multipart/parts", api_key=api_key,
                          json_body={"partNumbers": [number]})
        try:
            _put_slice(path, offset, min(part_size, file_size - offset),
                       signed["parts"][0]["url"])
        except GlossiFileError:
            raise
        except GlossiApiError as exc:
            # S3's 4xx can pass too: an expired URL (403) or its RequestTimeout (400).
            exc.transient = True
            raise

    def complete():
        nonlocal complete_unclear
        try:
            _request("POST", model_url + "/multipart/complete", api_key=api_key,
                     json_body={}, timeout=_COMPLETE_TIMEOUT_SECONDS)
        except GlossiApiError as exc:
            # A 429 never started; other transient failures may still be running on the server.
            if exc.transient and exc.http_status != 429:
                complete_unclear = True
            raise

    try:
        for number in range(1, part_count + 1):
            if number in held:
                continue
            say("Uploading part %d of %d..." % (number, part_count))
            _with_retries(lambda: send_part(number), say,
                          "Part %d failed, retrying..." % number)

        _check_unchanged(path, stamp)
        _with_retries(complete, say, "Finishing the upload failed, retrying...")
    except Exception:
        # The next attempt creates a new model, so these parts would stay billed.
        # Not after an unclear complete: an abort could race one still running.
        if not complete_unclear:
            try:
                _request("DELETE", model_url + "/multipart", api_key=api_key)
            except Exception:
                pass
        raise
    return True


def upload_model(path, api_key, name=None, file_type=None,
                 base_url=DEFAULT_BASE_URL, poll_seconds=6,
                 timeout_seconds=1800, progress=None, wait=True):
    """Upload a model file and block until Glossi has processed it.

    Create record -> send bytes to S3 in parts -> confirm -> poll status.
    Returns the final model dict from /models/status (status READY/APPROVED).
    With wait=False it returns the confirm response instead of polling, for
    hosts whose UI freezes during the call; a failed conversion then shows only
    in Glossi.

    `progress` is an optional callable(str) for UI status lines. Raises
    GlossiApiError on any failure, including server-side FAILED processing
    and the polling timeout.
    """
    try:
        return _upload_model(path, api_key, name, file_type, base_url,
                             poll_seconds, timeout_seconds, progress, wait)
    except (AttributeError, IndexError, KeyError, TypeError) as exc:
        # A response missing what we read. The plugins' workers only catch our error.
        raise GlossiApiError("unexpected response from Glossi: %r" % (exc,))


def _upload_model(path, api_key, name, file_type, base_url, poll_seconds,
                  timeout_seconds, progress, wait):
    def say(msg):
        if progress:
            progress(msg)

    file_type = file_type or file_type_for(path)
    if not file_type:
        raise GlossiApiError("cannot determine file type of %r" % path)
    file_name = os.path.basename(path)
    model_name = name or os.path.splitext(file_name)[0]

    stamp = _file_stamp(path)
    file_size = stamp[0]

    say("Registering model with Glossi...")
    created = _request("POST", base_url + "/models", api_key=api_key, json_body={
        "models": [{"name": model_name, "fileName": file_name,
                    "fileType": file_type, "fileSize": file_size}],
    })
    models = created.get("models") or []
    if not models:
        raise GlossiApiError("no upload URL returned: %s" % created.get("errors"))
    model_id = models[0]["modelId"]
    model_url = "%s/models/%s" % (base_url, model_id)

    say("Uploading %.1f MB..." % (file_size / 1e6))
    if not _upload_parts(path, api_key, model_url, stamp, say):
        _put_slice(path, 0, file_size, models[0]["uploadUrl"],
                   _CONTENT_TYPES.get(file_type, "application/octet-stream"))
        _check_unchanged(path, stamp)

    say("Confirming upload...")
    # A repeat is safe: the API answers success for a model it already confirmed.
    confirmed = _with_retries(
        lambda: _request("POST", "%s/models/%s/confirm" % (base_url, model_id),
                         api_key=api_key, json_body={"fileType": file_type}),
        say, "Confirming the upload failed, retrying...")
    if not wait:
        return confirmed

    start = time.monotonic()
    state = "PENDING"
    while True:
        delay = poll_seconds
        try:
            status = _request("POST", base_url + "/models/status", api_key=api_key,
                              json_body={"modelIds": [model_id]})
        except GlossiApiError as exc:
            # The model keeps converting on the server; reporting failure here prompts a re-upload.
            if not exc.transient:
                raise
            delay = _retry_delay(poll_seconds, exc)
            say("Can't reach Glossi, still waiting...")
        else:
            model = (status.get("models") or [{}])[0]
            state = model.get("status", "PENDING")
            if model.get("ready"):
                say("Model ready.")
                return model
            if state == "FAILED":
                raise GlossiApiError(
                    model.get("error") or "model processing failed server-side",
                    code="PROCESSING_FAILED")
            say("Processing (%s)..." % state)
        if time.monotonic() - start > timeout_seconds:
            raise GlossiApiError(
                "timed out after %ss waiting for processing (last status: %s)"
                % (timeout_seconds, state))
        time.sleep(delay)


# ---------------------------------------------------------------------------
# API key persistence
#
# One config file per host app so a machine with several DCCs keeps
# independent settings. GLOSSI_CONFIG_DIR overrides the location (tests).
# ---------------------------------------------------------------------------

def config_dir(app_name):
    override = os.environ.get("GLOSSI_CONFIG_DIR")
    if override:
        return os.path.join(override, app_name)
    if sys.platform == "win32":
        base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
        return os.path.join(base, "Glossi", app_name)
    if sys.platform == "darwin":
        return os.path.expanduser("~/Library/Application Support/Glossi/%s" % app_name)
    base = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config")
    return os.path.join(base, "glossi", app_name)


def _config_path(app_name):
    return os.path.join(config_dir(app_name), "config.json")


def load_config(app_name):
    try:
        with open(_config_path(app_name), "r") as f:
            return json.load(f)
    except (OSError, ValueError):
        return {}


def save_config(app_name, config):
    path = _config_path(app_name)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w") as f:
        json.dump(config, f, indent=2)
    try:
        os.chmod(path, 0o600)  # the config holds the API key
    except OSError:
        pass


def load_api_key(app_name):
    return load_config(app_name).get("api_key") or None


def save_api_key(app_name, api_key):
    config = load_config(app_name)
    config["api_key"] = api_key
    save_config(app_name, config)
").decode("utf-8"), glossi_client.__dict__)
_sys.modules["glossi_client"] = glossi_client

"""Glossi Uploader — CLO 3D plugin.

Registered via CLO's Plug-in Manager (Plugin tab > Plug-in Manager > + ADD).
When run, it exports the current garment as GLB using CLO's own export dialog
(so the user keeps control of export options) and uploads the result to the
Glossi workspace tied to the stored API key.

CLO injects its API as plain modules (export_api, utility_api). UI inside CLO
is limited: DisplayMessageBox is the only guaranteed dialog, so API-key entry
tries a Qt input dialog (CLO is Qt-based; PySide may be importable) and falls
back to a documented key file. Progress goes to CLO's Python log console.

Distribution is a single .py built by scripts/package_clo.py, which inlines
the shared glossi_client. In the repo, the client is a vendored sibling.
"""

import os
import re
import shutil
import sys
import tempfile


import export_api  # CLO-injected
import utility_api  # CLO-injected

APP_NAME = "clo"

# Fallback for entering the API key when no Qt input dialog is available:
# the user saves their key into this file once; the plugin imports and
# removes it. Documented in the setup guide.
KEY_DROP_FILE = os.path.join(os.path.expanduser("~"), "Documents", "CLO",
                             "glossi_api_key.txt")


def _say(msg):
    print("[Glossi] %s" % msg)


def _ask_api_key_qt():
    """Try a Qt password prompt. CLO embeds Qt, but PySide availability in its
    Python is undocumented — treat any failure as 'not available'."""
    try:
        try:
            from PySide6.QtWidgets import QApplication, QInputDialog, QLineEdit
        except ImportError:
            from PySide2.QtWidgets import QApplication, QInputDialog, QLineEdit
        if QApplication.instance() is None:
            return None
        text, ok = QInputDialog.getText(
            None, "Glossi",
            "Workspace API key (glsi_..., from Glossi workspace settings):",
            QLineEdit.Password)
        if ok and text and text.strip():
            return text.strip()
        return None
    except Exception:
        return None


def _key_from_drop_file():
    try:
        with open(KEY_DROP_FILE, "r") as f:
            key = f.read().strip()
        if key:
            try:
                os.remove(KEY_DROP_FILE)  # don't leave the secret on disk
            except OSError:
                pass
            return key
    except OSError:
        pass
    return None


def _ensure_api_key():
    key = glossi_client.load_api_key(APP_NAME)
    if key:
        return key
    key = _ask_api_key_qt() or _key_from_drop_file()
    if key:
        glossi_client.save_api_key(APP_NAME, key)
        return key
    utility_api.DisplayMessageBox(
        "Glossi: no API key configured.\n\n"
        "Create one in Glossi under Workspace Settings > API Keys, then either "
        "run this plug-in again (a prompt will appear if supported), or save "
        "the key as plain text into:\n%s\nand run the plug-in again."
        % KEY_DROP_FILE)
    return None


def _pick_glb(paths, fallback):
    for p in paths or []:
        if p and p.lower().endswith(".glb") and os.path.isfile(p):
            return p
    return fallback if os.path.isfile(fallback) else None


def run():
    key = _ensure_api_key()
    if not key:
        return

    base_url = glossi_client.resolve_base_url(APP_NAME)
    try:
        info = glossi_client.validate_key(key, base_url=base_url)
    except glossi_client.GlossiApiError as exc:
        if exc.http_status == 401:
            glossi_client.save_api_key(APP_NAME, "")
            utility_api.DisplayMessageBox(
                "Glossi: that API key was not accepted (revoked or mistyped). "
                "It has been cleared — run the plug-in again to enter a new one.")
        else:
            utility_api.DisplayMessageBox(
                "Glossi: could not reach the API.\n%s" % exc)
        return
    workspace = info["workspace"]["name"]
    _say("Connected to workspace: %s" % workspace)

    name = ""
    try:
        name = utility_api.GetProjectName() or ""
    except Exception:
        pass
    name = name.strip() or "CLO Garment"
    safe = re.sub(r"[^\w\-. ]", "_", name).strip() or "garment"

    out_dir = tempfile.mkdtemp(prefix="glossi_clo_")
    target = os.path.join(out_dir, safe + ".glb")

    _say("Opening CLO's GLB export dialog...")
    try:
        saved = export_api.ExportGLBWithDialog(target)
    except Exception as exc:
        shutil.rmtree(out_dir, ignore_errors=True)
        utility_api.DisplayMessageBox("Glossi: GLB export failed.\n%s" % exc)
        return

    glb_path = _pick_glb(saved, target)
    if glb_path is None:
        shutil.rmtree(out_dir, ignore_errors=True)
        _say("Export cancelled — nothing uploaded.")
        return

    _say("Uploading to %s — CLO may be unresponsive until this finishes." % workspace)
    try:
        model = glossi_client.upload_model(glb_path, key, name=name,
                                           base_url=base_url, progress=_say,
                                           wait=False)
    except glossi_client.GlossiApiError as exc:
        # Keep the GLB on disk for a manual retry.
        utility_api.DisplayMessageBox(
            "Glossi: upload failed.\n%s\n\nThe exported GLB is still at:\n%s"
            % (exc, glb_path))
        return

    shutil.rmtree(out_dir, ignore_errors=True)
    utility_api.DisplayMessageBox(
        "Glossi: \"%s\" is uploaded and processing. It will appear in the %s "
        "library (Library > Models) when ready." % (model["name"], workspace))


run()
