using System;
using UnityEngine;
using UnityEngine.Rendering;

public partial class MeshPainter
{
    // --- Pipette (eyedropper) --- (semantics: see the pipette tooltip; per-surface routing: PickAtScreen)

    [Header("Brush - pipette (eyedropper)")]
    [Tooltip("Pipette mode: a click samples the channel values at the hit point on ANY surface " +
             "(albedo, metallic, smoothness, emission) and adopts them into the brush (opacities/alphas " +
             "left untouched) instead of painting. Height (occlusion) and fur length are adopted and their " +
             "toggles enabled only when our own paint mesh is picked; any other surface disables those " +
             "toggles and keeps their values. On a " +
             "foreign object the data channels are read texel-exact from the material; albedo follows " +
             "'Pipette Albedo From Screen'. Held button picks once.")]
    public bool pipette = false;

    [Tooltip("On a foreign-object pick, where albedo comes from. OFF (default): albedo is read " +
             "texel-exact from the material like the other channels (raw, unlit). ON: albedo is taken " +
             "from the lit on-screen pixel ('what you see' - honours baked lightmaps/ambient/SSAO). " +
             "The data channels (metallic/smoothness/emission) always come from the material.")]
    [SerializeField] private bool pipetteAlbedoFromScreen = false;

    /// <summary>
    /// Raised after a successful pick, once the brush has adopted the sampled values and all four
    /// paint-channel flags have been enabled. The in-game HUD listens to re-sync its widgets.
    /// </summary>
    public event Action Picked;

    private bool _pickHeld; // edge tracking so a held button picks once, not every frame

    // A terrain hit higher than this above the heightfield is a tree (trees share the terrain
    // collider but stand proud of the ground); on the surface it is bare ground.
    private const float TerrainFoliageHeightEpsilon = 0.3f;

    /// <summary>
    /// Raycasts at a screen position against ANY collider (regardless of which channels are toggled),
    /// samples the channel values at the hit and adopts them into the brush (toggle rules: see
    /// <see cref="FinalizePick"/>). Pick paths, by what was hit:
    ///   - our paint mesh        -> texel-exact from the painted maps (full PBR);
    ///   - terrain ground        -> blend of the terrain layers by their splat weights (full PBR);
    ///   - terrain tree / detail -> the rendered on-screen colour (no per-instance renderer/UV);
    ///   - any foreign object     -> data channels texel-exact from the material; albedo from the
    ///                               material or the lit on-screen pixel per pipetteAlbedoFromScreen;
    ///   - anything else / sky    -> the rendered on-screen colour.
    /// </summary>
    private void PickAtScreen(Vector2 screenPos)
    {
        bool ok;
        bool pickedHeight = false; // height is only meaningful off our OWN painted maps
        if (TryRaycastAny(screenPos, out RaycastHit hit))
        {
            if (hit.collider == _collider)
            {
                ok = PickFromPaintTextures(hit);
                pickedHeight = ok;
            }
            else
            {
                Terrain terrain = hit.collider is TerrainCollider ? hit.collider.GetComponent<Terrain>() : null;
                if (terrain)
                    ok = PickFromTerrain(terrain, hit, screenPos);
                else
                    ok = PickFromForeignHybrid(hit, screenPos);
            }
        }
        else
        {
            // Ray left the scene entirely (e.g. foliage against the sky) - only the screen pixel remains.
            ok = PickFromScreen(screenPos);
        }
        if (!ok) return;

        FinalizePick(pickedHeight);
    }

    /// <summary>
    /// Common tail of every successful pick: enables the sampled paint channels (height only when our
    /// own paint mesh was picked - any other surface disables its toggle and keeps the value), leaves
    /// pipette mode (one-shot) and notifies listeners (the HUD) to re-sync their widgets.
    /// </summary>
    private void FinalizePick(bool pickedHeight)
    {
        paintAlbedo = true;
        paintMetallicSmoothness = true;
        paintOcclusion = pickedHeight;
        paintEmission = true;
        // Fur mirrors height/occlusion: adopted and its toggle enabled only when our OWN paint mesh was
        // picked (pickedHeight, where furLength was sampled); any other surface disables the fur toggle
        // and keeps furLength.
        fur = pickedHeight;

        pipette = false;

        Picked?.Invoke();
    }

    /// <summary>Adopts a sampled colour as the brush albedo, preserving the brush's paint opacity (alpha).</summary>
    private void AdoptAlbedo(Color c) =>
        brushColor = new Color(Mathf.Clamp01(c.r), Mathf.Clamp01(c.g), Mathf.Clamp01(c.b), brushColor.a);

    /// <summary>Zeroes the emission colour, preserving its paint opacity (alpha).</summary>
    private void ClearEmissionRgb() =>
        emissionColor = new Color(0f, 0f, 0f, emissionColor.a);

    /// <summary>
    /// Picks from our own painted maps at the hit texel (bit-exact, backend-agnostic).
    /// </summary>
    private bool PickFromPaintTextures(RaycastHit hit)
    {
        if (_verts == null || _uvs == null || _tris == null || hit.triangleIndex < 0) return false;

        int t = hit.triangleIndex;
        if (t * 3 + 2 >= _tris.Length) return false;
        int i0 = _tris[t * 3], i1 = _tris[t * 3 + 1], i2 = _tris[t * 3 + 2];

        // UV at the hit via barycentric interpolation of the cached UVs - same UV space the
        // brush paints into, so the sampled texel is exactly the one that would be painted.
        Vector3 bc = hit.barycentricCoordinate;
        Vector2 uv = _uvs[i0] * bc.x + _uvs[i1] * bc.y + _uvs[i2] * bc.z;

        int px = Mathf.Clamp(Mathf.FloorToInt(uv.x * textureSize), 0, textureSize - 1);
        int py = Mathf.Clamp(Mathf.FloorToInt(uv.y * textureSize), 0, textureSize - 1);
        int idx = py * textureSize + px;

        // ReadCanonical gives material layout for either backend:
        //   albedo   -> sRGB RGB
        //   MSO      -> R = metallic, G = occlusion, A = smoothness (linear data)
        //   emission -> sRGB RGB
        Color32[] alb = ReadCanonical(MAP_ALBEDO);
        Color32[] mso = ReadCanonical(MAP_MSO);
        Color32[] em = ReadCanonical(MAP_EM);
        Color32[] fur = ReadCanonical(MAP_FUR);
        if (idx < 0 || idx >= alb.Length || idx >= mso.Length || idx >= em.Length || idx >= fur.Length) return false;

        Color32 a = alb[idx];
        Color32 m = mso[idx];
        Color32 e = em[idx];

        // sRGB bytes map straight back into the gamma-space brush colours (round-trips exactly). The
        // alpha (paint opacity) is deliberately preserved, not overwritten - a pick changes only the colour.
        brushColor = new Color(a.r / 255f, a.g / 255f, a.b / 255f, brushColor.a);
        metallic = m.r / 255f;
        smoothness = m.a / 255f;
        occlusion = m.g / 255f; // the painted HEIGHT - adopted only off our own mesh (FinalizePick)
        emissionColor = new Color(e.r / 255f, e.g / 255f, e.b / 255f, emissionColor.a);
        furLength = fur[idx].r / 255f; // fur map carries only R = painted length (linear data)
        return true;
    }

    /// <summary>
    /// Foreign-object pick: data channels always texel-exact from the material (raw, unlit); albedo
    /// optionally overwritten with the fully-lit on-screen pixel (<see cref="pipetteAlbedoFromScreen"/>).
    /// Falls back to a pure screen pick when no texel-exact material read is possible.
    /// </summary>
    private bool PickFromForeignHybrid(RaycastHit hit, Vector2 screenPos)
    {
        if (PickFromForeignMaterial(hit))
        {
            // No camera (headless) -> keep the material's raw albedo rather than failing.
            if (pipetteAlbedoFromScreen && TrySampleScreenColor(screenPos, out Color lit))
                AdoptAlbedo(lit);
            return true;
        }

        return PickFromScreen(screenPos);
    }

    /// <summary>
    /// Picks from a foreign object's material at the hit UV: texel-exact texture samples
    /// (where a UV at the hit can be resolved and the map exists) combined with the material
    /// scalars per the URP/Lit conventions, with scalar fallbacks everywhere else.
    /// </summary>
    private bool PickFromForeignMaterial(RaycastHit hit)
    {
        Collider col = hit.collider;
        if (!col) return false;
        Renderer rend = col.GetComponent<Renderer>();
        if (!rend) rend = col.GetComponentInParent<Renderer>();
        if (!rend) return false;

        // hit.textureCoord is only populated for a NON-convex MeshCollider (convex/primitive colliders
        // return zero) - recover the UV from the renderer's own mesh then. The hit SUBMESH is resolved
        // alongside so a multi-material renderer reads the covering sub-material, not always slot 0.
        Vector2 uv;
        bool hasUv;
        int subMesh;
        if (col is MeshCollider mc && !mc.convex && hit.triangleIndex >= 0)
        {
            uv = hit.textureCoord;
            hasUv = true;
            subMesh = SubMeshFromIndex(mc.sharedMesh, hit.triangleIndex * 3);
        }
        else
        {
            hasUv = TryRecoverMeshUv(rend, hit, out uv, out subMesh);
        }

        // One material per submesh: pick the slot the hit submesh maps to (clamped, so a renderer with
        // fewer materials than submeshes still reads). Reads the shared material - never instances it.
        Material[] mats = rend.sharedMaterials;
        Material mat = (mats != null && mats.Length > 0)
            ? mats[Mathf.Clamp(subMesh, 0, mats.Length - 1)]
            : null;
        if (!mat) return false;

        // Base map but no UV resolvable: defer to the on-screen pixel (which at least reflects the
        // texture) rather than silently picking the flat _BaseColor.
        if (!hasUv && GetTexProp(mat, "_BaseMap", "_MainTex", "_Albedo")) return false;

        // --- Albedo: BaseMap (sRGB) * BaseColor ---
        // AVP/* shaders name the map "_Albedo" and the tint "_AlbedoColor" (Glass tints via "_Color").
        Color baseCol = GetColorProp(mat, Color.white, "_BaseColor", "_AlbedoColor", "_Color");
        Texture baseTex = GetTexProp(mat, "_BaseMap", "_MainTex", "_Albedo");
        Color albedo = baseCol;
        if (hasUv && baseTex)
            albedo = SampleTexel(baseTex, ApplyST(mat, uv, "_BaseMap", "_MainTex", "_Albedo"), true) * baseCol;
        AdoptAlbedo(albedo);

        // --- Metallic: mask map .r * power, else flat scalar (linear) ---
        // URP/Lit: _MetallicGlossMap.r (or the flat _Metallic scalar when no map). AVP name the mask
        // "_Metallic" (a TEXTURE) and POM multiplies it by "_Metallic_Power"; Glass' "_Metallic" is a
        // flat FLOAT. The type-checked reads resolve the "_Metallic" texture-vs-float collision per shader.
        Texture metTex = GetTexProp(mat, "_MetallicGlossMap", "_Metallic");
        float metallicVal;
        if (hasUv && metTex)
            metallicVal = SampleTexel(metTex, ApplyST(mat, uv, "_MetallicGlossMap", "_Metallic"), false).r
                          * GetFloatProp(mat, 1f, "_Metallic_Power"); // POM power; neutral 1 for URP/Velvet
        else
            metallicVal = GetFloatProp(mat, 0f, "_Metallic");         // URP/Glass flat scalar
        metallic = Mathf.Clamp01(metallicVal);

        // --- Smoothness: mask map .a * scalar (linear) ---
        // Alpha source: URP _MetallicGlossMap, AVP POM/Velvet/Curtains the "_Metallic" mask, Glass a
        // dedicated "_Smoothness" TEXTURE. Scalar: _Smoothness/_Glossiness (URP/Velvet) or _SmoothnessPower
        // (POM); Glass has none -> neutral 1 so smoothness = map.a. ("_Smoothness" is a float in Velvet but
        // a texture in Glass - both handled by the type-checked reads.)
        Texture smTex = GetTexProp(mat, "_MetallicGlossMap", "_Metallic", "_Smoothness");
        float smoothVal;
        if (hasUv && smTex)
            smoothVal = SampleTexel(smTex, ApplyST(mat, uv, "_MetallicGlossMap", "_Metallic", "_Smoothness"), false).a
                        * GetFloatProp(mat, 1f, "_Smoothness", "_Glossiness", "_SmoothnessPower");
        else
            smoothVal = GetFloatProp(mat, 0.5f, "_Smoothness", "_Glossiness", "_SmoothnessPower");
        smoothness = Mathf.Clamp01(smoothVal);

        // Occlusion is deliberately NOT sampled (that channel drives painted height now, see FinalizePick).

        // --- Emission: EmissionMap (sRGB) * tint/intensity ---
        // URP/Standard: _EmissionMap * _EmissionColor. AVP Velvet/Curtains: "_Emission" TEXTURE *
        // "_Emission_Power" (a scalar intensity, no colour tint). POM/Glass have no emission.
        Texture emTex = GetTexProp(mat, "_EmissionMap", "_Emission");
        float emPower = GetFloatProp(mat, -1f, "_Emission_Power"); // >=0 marks the AVP intensity path
        Color emCol;
        if (emPower >= 0f)
            emCol = (hasUv && emTex)
                ? SampleTexel(emTex, ApplyST(mat, uv, "_EmissionMap", "_Emission"), true) * emPower
                : Color.black;
        else
        {
            Color emColor = GetColorProp(mat, Color.black, "_EmissionColor");
            emCol = (hasUv && emTex)
                ? SampleTexel(emTex, ApplyST(mat, uv, "_EmissionMap", "_Emission"), true) * emColor
                : emColor;
        }
        emissionColor = new Color(Mathf.Clamp01(emCol.r), Mathf.Clamp01(emCol.g), Mathf.Clamp01(emCol.b), emissionColor.a);

        return true;
    }

    /// <summary>
    /// Picks at a terrain hit. The TerrainCollider also carries the painted TREES (which sit above
    /// the heightfield and expose no per-instance renderer/UV here), and grass/mushroom DETAILS have
    /// no collider at all:
    ///   - hit above the surface  -> a tree: adopt the rendered on-screen colour;
    ///   - hit on a cell that has grass/mushroom detail -> adopt the on-screen colour;
    ///   - otherwise (bare ground) -> blend the terrain layers by their splat weights (full PBR).
    /// </summary>
    private bool PickFromTerrain(Terrain terrain, RaycastHit hit, Vector2 screenPos)
    {
        TerrainData td = terrain.terrainData;
        if (!td) return false;
        Vector3 tpos = terrain.transform.position;
        Vector3 size = td.size;
        if (size.x <= 1e-4f || size.z <= 1e-4f) return false;

        // Trees share the terrain collider but stand proud of the heightfield.
        float surfaceY = terrain.SampleHeight(hit.point) + tpos.y;
        if (hit.point.y > surfaceY + TerrainFoliageHeightEpsilon)
            return PickFromScreen(screenPos);

        Vector3 local = hit.point - tpos;
        float nx = Mathf.Clamp01(local.x / size.x);
        float nz = Mathf.Clamp01(local.z / size.z);

        // Grass/mushroom detail rendered on this ground cell -> what's visible there is the
        // foliage (which has no collider of its own), so trust the screen pixel.
        if (TerrainHasDetail(td, nx, nz))
            return PickFromScreen(screenPos);

        return PickFromTerrainLayers(td, local, nx, nz);
    }

    /// <summary>
    /// Blends the terrain's layers at a ground point by their splat (alphamap) weights: the weighted
    /// diffuse colour becomes albedo and the weighted per-layer metallic/smoothness scalars feed
    /// those channels; emission is black (occlusion is left as the brush's height value). Terrain has no Renderer/material, so this
    /// is the only way to read its surface.
    /// </summary>
    private bool PickFromTerrainLayers(TerrainData td, Vector3 local, float nx, float nz)
    {
        int aw = td.alphamapWidth, ah = td.alphamapHeight;
        int mapX = Mathf.Clamp(Mathf.FloorToInt(nx * aw), 0, aw - 1);
        int mapZ = Mathf.Clamp(Mathf.FloorToInt(nz * ah), 0, ah - 1);
        float[,,] weights = td.GetAlphamaps(mapX, mapZ, 1, 1);

        TerrainLayer[] layers = td.terrainLayers;
        int count = Mathf.Min(layers.Length, weights.GetLength(2));
        Color albedo = Color.black;
        float metallicVal = 0f, smoothVal = 0f, weightSum = 0f;
        for (int i = 0; i < count; i++)
        {
            TerrainLayer L = layers[i];
            if (!L) continue;
            float w = weights[0, 0, i];
            if (w <= 0f) continue;

            Color col = Color.gray;
            if (L.diffuseTexture)
            {
                // Terrain tiles each layer across the world by tileSize (metres); sample that texel.
                Vector2 uv = new Vector2(
                    (local.x - L.tileOffset.x) / Mathf.Max(1e-4f, L.tileSize.x),
                    (local.z - L.tileOffset.y) / Mathf.Max(1e-4f, L.tileSize.y));
                col = SampleTexel(L.diffuseTexture, uv, true);
            }
            albedo += col * w;
            metallicVal += L.metallic * w;
            smoothVal += L.smoothness * w;
            weightSum += w;
        }
        if (weightSum <= 1e-4f) return false;
        float inv = 1f / weightSum; // alphamap weights normally sum to 1, but guard anyway

        AdoptAlbedo(albedo * inv);
        metallic = Mathf.Clamp01(metallicVal * inv);
        smoothness = Mathf.Clamp01(smoothVal * inv);
        ClearEmissionRgb(); // occlusion left untouched (now painted height)
        return true;
    }

    /// <summary>
    /// True when any grass/mushroom detail layer has coverage at the given normalized terrain
    /// position - i.e. foliage (which carries no collider) is rendered on that ground cell.
    /// </summary>
    private static bool TerrainHasDetail(TerrainData td, float nx, float nz)
    {
        int dw = td.detailWidth, dh = td.detailHeight;
        if (dw <= 0 || dh <= 0) return false;
        int dx = Mathf.Clamp(Mathf.FloorToInt(nx * dw), 0, dw - 1);
        int dy = Mathf.Clamp(Mathf.FloorToInt(nz * dh), 0, dh - 1);
        int layerCount = td.detailPrototypes.Length;
        for (int i = 0; i < layerCount; i++)
        {
            int[,] d = td.GetDetailLayer(dx, dy, 1, 1, i);
            if (d[0, 0] > 0) return true;
        }
        return false;
    }

    /// <summary>
    /// Fallback colour pick: reads the rendered pixel under the cursor (the paint camera re-rendered
    /// to a temporary target, so it works on either render pipeline). Used for surfaces that can't be
    /// sampled texel-exact - terrain trees and grass/mushroom details (no per-instance renderer/UV)
    /// and anything hit without a readable material, plus rays that miss all geometry. Only albedo is
    /// meaningful from a screen pixel; the data channels default to matte/unoccluded/no-emission.
    /// </summary>
    private bool PickFromScreen(Vector2 screenPos)
    {
        if (!TrySampleScreenColor(screenPos, out Color c)) return false;

        AdoptAlbedo(c);
        metallic = 0f;
        smoothness = 0f;
        ClearEmissionRgb(); // occlusion left untouched (now painted height)
        return true;
    }

    /// <summary>
    /// Reads the rendered pixel under the cursor (the paint camera re-rendered to a temporary target,
    /// so it works on either render pipeline) without touching any brush channel. Returns the fully-lit
    /// on-screen colour - what is visible, including baked lightmaps/ambient/SSAO. False when no camera
    /// is bound (headless). Shared by <see cref="PickFromScreen"/> and the hybrid albedo override.
    /// </summary>
    private bool TrySampleScreenColor(Vector2 screenPos, out Color color)
    {
        color = default;
        Camera cam = paintCamera;
        if (!cam) return false;
        int w = Mathf.Max(1, cam.pixelWidth), h = Mathf.Max(1, cam.pixelHeight);

        RenderTexture rt = RenderTexture.GetTemporary(w, h, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);
        RenderTexture prevTarget = cam.targetTexture;
        RenderTexture prevActive = RenderTexture.active;
        cam.targetTexture = rt;
        cam.Render();
        RenderTexture.active = rt;

        var tmp = new Texture2D(1, 1, TextureFormat.RGBA32, false, false);
        int px = Mathf.Clamp(Mathf.RoundToInt(screenPos.x), 0, w - 1);
        int py = Mathf.Clamp(Mathf.RoundToInt(screenPos.y), 0, h - 1);
        tmp.ReadPixels(new Rect(px, py, 1, 1), 0, 0, false);
        tmp.Apply(false);
        color = tmp.GetPixel(0, 0);

        cam.targetTexture = prevTarget;
        RenderTexture.active = prevActive;
        RenderTexture.ReleaseTemporary(rt);
        if (Application.isPlaying) Destroy(tmp); else DestroyImmediate(tmp);
        return true;
    }

    // --- Material read helpers (name-tolerant: URP and legacy Standard) ---

    // A name can collide across types (e.g. AVP names "_Metallic"/"_Smoothness" as a TEXTURE while
    // URP/Lit uses them as floats). HasProperty ignores type, so GetFloat/GetColor on the wrong-typed
    // property spams a Unity error every hover frame - match the expected type before reading.
    private static bool HasProp(Material m, string n, ShaderPropertyType type)
    {
        if (n == null) return false;
        Shader s = m.shader;
        int i = s.FindPropertyIndex(n);
        if (i < 0) return false;
        ShaderPropertyType t = s.GetPropertyType(i);
        return type == ShaderPropertyType.Float ? (t == ShaderPropertyType.Float || t == ShaderPropertyType.Range)
             : type == ShaderPropertyType.Color ? (t == ShaderPropertyType.Color || t == ShaderPropertyType.Vector)
             : t == type;
    }

    // Names are tried in order; first match of the right type wins. Covers URP/Lit, legacy Standard
    // AND the bespoke AVP/* naming (_Albedo / _AlbedoColor) from one call site.
    private static Color GetColorProp(Material m, Color fallback, params string[] names)
    {
        foreach (string n in names)
            if (HasProp(m, n, ShaderPropertyType.Color)) return m.GetColor(n);
        return fallback;
    }

    private static float GetFloatProp(Material m, float fallback, params string[] names)
    {
        foreach (string n in names)
            if (HasProp(m, n, ShaderPropertyType.Float)) return m.GetFloat(n);
        return fallback;
    }

    private static Texture GetTexProp(Material m, params string[] names)
    {
        foreach (string n in names)
            if (HasProp(m, n, ShaderPropertyType.Texture)) { Texture t = m.GetTexture(n); if (t) return t; }
        return null;
    }

    private static Vector2 ApplyST(Material m, Vector2 uv, params string[] names)
    {
        string prop = null;
        foreach (string n in names)
            if (HasProp(m, n, ShaderPropertyType.Texture)) { prop = n; break; }
        if (prop == null) return uv;
        Vector2 s = m.GetTextureScale(prop);
        Vector2 o = m.GetTextureOffset(prop);
        return new Vector2(uv.x * s.x + o.x, uv.y * s.y + o.y);
    }

    /// <summary>
    /// Samples a single texel from a texture at a UV (texel-exact). Uses GetPixelBilinear when the
    /// texture is CPU-readable; otherwise blits it to a temporary RenderTexture and reads back the
    /// one texel, so it works regardless of the texture's "Read/Write" import flag. <paramref
    /// name="srgb"/> selects the colour space so the returned value matches the readable path
    /// (gamma for colour maps, linear for data maps).
    /// </summary>
    private static Color SampleTexel(Texture tex, Vector2 uv, bool srgb)
    {
        Texture2D t2d = tex as Texture2D;
        if (t2d && t2d.isReadable)
            return t2d.GetPixelBilinear(uv.x, uv.y);

        int w = Mathf.Max(1, tex.width), h = Mathf.Max(1, tex.height);
        var rw = srgb ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear;
        RenderTexture rt = RenderTexture.GetTemporary(w, h, 0, RenderTextureFormat.ARGB32, rw);
        RenderTexture prev = RenderTexture.active;
        Graphics.Blit(tex, rt);
        RenderTexture.active = rt;

        var tmp = new Texture2D(1, 1, TextureFormat.RGBA32, false, !srgb);
        int px = Mathf.Clamp(Mathf.FloorToInt(Mathf.Repeat(uv.x, 1f) * w), 0, w - 1);
        int py = Mathf.Clamp(Mathf.FloorToInt(Mathf.Repeat(uv.y, 1f) * h), 0, h - 1);
        tmp.ReadPixels(new Rect(px, py, 1, 1), 0, 0, false);
        tmp.Apply(false);
        Color c = tmp.GetPixel(0, 0);

        RenderTexture.active = prev;
        RenderTexture.ReleaseTemporary(rt);
        if (Application.isPlaying) Destroy(tmp); else DestroyImmediate(tmp);
        return c;
    }

    /// <summary>
    /// Recovers the UV at a hit point by intersecting the camera ray with the renderer's own mesh
    /// (Moller-Trumbore against each triangle, nearest hit wins). Needed when the collider that was
    /// hit cannot supply hit.textureCoord - a convex MeshCollider or any primitive collider. Requires
    /// a MeshFilter whose mesh is readable and UV-mapped; returns false otherwise so the caller can
    /// fall back. A one-shot click cost, so the O(triangles) sweep is acceptable.
    /// </summary>
    private bool TryRecoverMeshUv(Renderer rend, RaycastHit hit, out Vector2 uv, out int subMesh)
    {
        uv = default;
        subMesh = 0;
        if (!rend) return false;
        MeshFilter mf = rend.GetComponent<MeshFilter>();
        Mesh mesh = mf ? mf.sharedMesh : null;
        if (!mesh || !mesh.isReadable) return false;

        Vector2[] uvs = mesh.uv;
        if (uvs == null || uvs.Length == 0) return false;
        Vector3[] verts = mesh.vertices;
        int[] tris = mesh.triangles;

        // Ray from the paint camera through the surface point (its UV is what we want). Fall back to
        // shooting along the inverted hit normal when no camera is bound.
        Vector3 ro, rd;
        if (paintCamera)
        {
            ro = paintCamera.transform.position;
            rd = (hit.point - ro).normalized;
        }
        else
        {
            rd = -hit.normal;
            ro = hit.point - rd * 0.01f;
        }

        Matrix4x4 l2w = rend.transform.localToWorldMatrix;
        float bestT = float.MaxValue;
        Vector3 bestBary = default;
        int bestTri = -1;
        for (int i = 0; i + 2 < tris.Length; i += 3)
        {
            Vector3 a = l2w.MultiplyPoint3x4(verts[tris[i]]);
            Vector3 b = l2w.MultiplyPoint3x4(verts[tris[i + 1]]);
            Vector3 c = l2w.MultiplyPoint3x4(verts[tris[i + 2]]);
            if (RayTriangle(ro, rd, a, b, c, out float t, out float u, out float v) && t < bestT)
            {
                bestT = t;
                bestBary = new Vector3(1f - u - v, u, v);
                bestTri = i;
            }
        }
        if (bestTri < 0) return false;

        uv = uvs[tris[bestTri]] * bestBary.x + uvs[tris[bestTri + 1]] * bestBary.y + uvs[tris[bestTri + 2]] * bestBary.z;
        subMesh = SubMeshFromIndex(mesh, bestTri); // bestTri is the offset into the flattened index buffer
        return true;
    }

    /// <summary>
    /// Resolves which submesh a triangle belongs to, given its offset into the mesh's flattened index
    /// buffer (triangleNumber * 3, matching the <see cref="Mesh.triangles"/> layout). Submesh index then
    /// maps 1:1 onto the renderer's material slots. Returns 0 for a single-material mesh (the common
    /// case, no descriptor lookup) or when the mesh is missing.
    /// </summary>
    private static int SubMeshFromIndex(Mesh mesh, int indexOffset)
    {
        if (!mesh) return 0;
        int subCount = mesh.subMeshCount;
        if (subCount <= 1) return 0;
        for (int s = 0; s < subCount; s++)
        {
            UnityEngine.Rendering.SubMeshDescriptor d = mesh.GetSubMesh(s);
            if (indexOffset >= d.indexStart && indexOffset < d.indexStart + d.indexCount)
                return s;
        }
        return 0;
    }

    /// <summary>
    /// Moller-Trumbore ray/triangle intersection. On a hit, <paramref name="t"/> is the ray distance
    /// and (<paramref name="u"/>, <paramref name="v"/>) are the barycentric weights of vertices b and
    /// c (vertex a's weight is 1 - u - v). Small epsilons admit edge hits.
    /// </summary>
    private static bool RayTriangle(Vector3 ro, Vector3 rd, Vector3 a, Vector3 b, Vector3 c,
        out float t, out float u, out float v)
    {
        t = u = v = 0f;
        const float eps = 1e-7f;
        Vector3 e1 = b - a, e2 = c - a;
        Vector3 p = Vector3.Cross(rd, e2);
        float det = Vector3.Dot(e1, p);
        if (det > -eps && det < eps) return false; // ray parallel to the triangle
        float inv = 1f / det;
        Vector3 tvec = ro - a;
        u = Vector3.Dot(tvec, p) * inv;
        if (u < -1e-4f || u > 1f + 1e-4f) return false;
        Vector3 q = Vector3.Cross(tvec, e1);
        v = Vector3.Dot(rd, q) * inv;
        if (v < -1e-4f || u + v > 1f + 1e-4f) return false;
        t = Vector3.Dot(e2, q) * inv;
        return t > eps;
    }
}