/*
 * Copyright © 2026  Behdad Esfahbod
 *
 *  This is part of HarfBuzz, a text shaping library.
 *
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the
 * above copyright notice and the following two paragraphs appear in
 * all copies of this software.
 *
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * Author(s): Behdad Esfahbod
 */

#ifndef HB_NO_RASTER_SVG

#include "hb.hh"

#include "hb-raster-svg-clip.hh"

#include "hb-raster.h"
#include "hb-raster-paint.hh"
#include "hb-raster-svg.hh"
#include "hb-raster-svg-base.hh"
#include "hb-decycler.hh"

#include <math.h>

static inline bool
svg_transform_is_identity (const hb_svg_transform_t &t)
{
  return t.xx == 1.f && t.yx == 0.f &&
         t.xy == 0.f && t.yy == 1.f &&
         t.dx == 0.f && t.dy == 0.f;
}

static bool
svg_parse_element_transform (hb_svg_xml_parser_t &parser,
                             hb_svg_transform_t *out)
{
  hb_svg_style_props_t style_props;
  svg_parse_style_props (parser.find_attr ("style"), &style_props);
  hb_svg_str_t transform = svg_pick_attr_or_style (parser, style_props.transform, "transform");
  if (!transform.len)
    return false;
  hb_raster_svg_parse_transform (transform, out);
  return true;
}

struct hb_svg_clip_collect_context_t
{
  hb_svg_defs_t *defs;
  hb_svg_clip_path_def_t *clip;
  const char *doc_start;
  unsigned doc_len;
  const OT::SVG::accelerator_t *svg_accel;
  const OT::SVG::svg_doc_cache_t *doc_cache;
  hb_decycler_t *use_decycler;
  bool *had_alloc_failure;
};

static inline void
svg_clip_append_shape (hb_svg_clip_collect_context_t *ctx,
                       const hb_svg_shape_emit_data_t &shape,
                       const hb_svg_transform_t &transform)
{
  hb_svg_clip_shape_t clip_shape;
  clip_shape.shape = shape;
  if (!svg_transform_is_identity (transform))
  {
    clip_shape.has_transform = true;
    clip_shape.transform = transform;
  }
  if (likely (ctx->defs->clip_shapes.push_or_fail (clip_shape)))
    ctx->clip->shape_count++;
  else if (ctx->had_alloc_failure)
    *ctx->had_alloc_failure = true;
}

static void
svg_skip_subtree (hb_svg_xml_parser_t &parser)
{
  int depth = 1;
  while (depth > 0)
  {
    hb_svg_token_type_t tok = parser.next ();
    if (tok == SVG_TOKEN_EOF) break;
    if (tok == SVG_TOKEN_CLOSE_TAG) depth--;
    else if (tok == SVG_TOKEN_OPEN_TAG) depth++;
  }
}

static inline bool
svg_resolve_element_visibility (hb_svg_xml_parser_t &parser,
                                bool parent_visible)
{
  hb_svg_style_props_t style_props;
  svg_parse_style_props (parser.find_attr ("style"), &style_props);
  hb_svg_str_t display_str = svg_pick_attr_or_style (parser, style_props.display, "display");
  hb_svg_str_t visibility_str = svg_pick_attr_or_style (parser, style_props.visibility, "visibility");
  if (display_str.trim ().eq_ascii_ci ("none"))
    return false;
  hb_svg_str_t vis_trim = visibility_str.trim ();
  if (!vis_trim.len || vis_trim.eq_ascii_ci ("inherit"))
    return parent_visible;
  if (vis_trim.eq_ascii_ci ("hidden") ||
      vis_trim.eq_ascii_ci ("collapse"))
    return false;
  if (vis_trim.eq_ascii_ci ("visible"))
    return true;
  return parent_visible;
}

static void
svg_clip_collect_ref_element (hb_svg_clip_collect_context_t *ctx,
                              hb_svg_xml_parser_t &parser,
                              const hb_svg_transform_t &base_transform,
                              unsigned depth,
                              bool suppress_viewbox_once = false,
                              bool parent_visible = true,
                              bool allow_symbol_once = false);

static void
svg_clip_collect_use_target (hb_svg_clip_collect_context_t *ctx,
                             hb_svg_xml_parser_t &use_parser,
                             const hb_svg_transform_t &base_transform,
                             unsigned depth)
{
  const unsigned SVG_MAX_CLIP_USE_DEPTH = 64;
  if (depth >= SVG_MAX_CLIP_USE_DEPTH)
    return;

  hb_svg_str_t href = hb_raster_svg_find_href_attr (use_parser);
  hb_svg_str_t ref_id;
  if (!hb_raster_svg_parse_local_id_ref (href, &ref_id, nullptr))
    return;

  const char *found = nullptr;
  if (!hb_raster_svg_find_element_by_id (ctx->doc_start, ctx->doc_len,
                                         ctx->svg_accel, ctx->doc_cache,
                                         ref_id, &found))
    return;

  hb_decycler_node_t node (*ctx->use_decycler);
  if (unlikely (!node.visit ((uintptr_t) found)))
    return;

  hb_svg_transform_t effective = base_transform;
  float use_x = 0.f, use_y = 0.f, use_w = 0.f, use_h = 0.f;
  hb_raster_svg_parse_use_geometry (use_parser, &use_x, &use_y, &use_w, &use_h);
  if (use_x != 0.f || use_y != 0.f)
  {
    hb_svg_transform_t tr;
    tr.dx = use_x;
    tr.dy = use_y;
    effective.multiply (tr);
  }

  unsigned remaining = ctx->doc_len - (unsigned) (found - ctx->doc_start);
  hb_svg_xml_parser_t ref_parser (found, remaining);
  hb_svg_token_type_t rt = ref_parser.next ();
  if (rt != SVG_TOKEN_OPEN_TAG && rt != SVG_TOKEN_SELF_CLOSE_TAG)
    return;

  bool viewport_mapped = false;
  hb_svg_transform_t vb_t;
  if (hb_raster_svg_compute_use_target_viewbox_transform (ref_parser, use_w, use_h, &vb_t))
  {
    effective.multiply (vb_t);
    viewport_mapped = true;
  }

  bool allow_symbol = ref_parser.tag_name.eq ("symbol");
  svg_clip_collect_ref_element (ctx, ref_parser, effective, depth + 1,
                                viewport_mapped, true, allow_symbol);
}

static void
svg_clip_collect_ref_element (hb_svg_clip_collect_context_t *ctx,
                              hb_svg_xml_parser_t &parser,
                              const hb_svg_transform_t &base_transform,
                              unsigned depth,
                              bool suppress_viewbox_once,
                              bool parent_visible,
                              bool allow_symbol_once)
{
  const unsigned SVG_MAX_CLIP_REF_DEPTH = 64;
  if (depth >= SVG_MAX_CLIP_REF_DEPTH)
  {
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }

  bool is_visible = svg_resolve_element_visibility (parser, parent_visible);
  if (!is_visible)
  {
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }

  /* Definitions are not directly renderable clip geometry. */
  if (parser.tag_name.eq ("defs"))
  {
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }
  if (parser.tag_name.eq ("symbol") && !allow_symbol_once)
  {
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }
  if (parser.tag_name.eq ("symbol"))
    allow_symbol_once = false;

  hb_svg_transform_t effective = base_transform;
  hb_svg_style_props_t geom_style_props;
  svg_parse_style_props (parser.find_attr ("style"), &geom_style_props);
  hb_svg_transform_t local_t;
  if (svg_parse_element_transform (parser, &local_t))
    effective.multiply (local_t);
  if (parser.tag_name.eq ("svg"))
  {
    float svg_x = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, geom_style_props.x, "x"));
    float svg_y = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, geom_style_props.y, "y"));
    if (svg_x != 0.f || svg_y != 0.f)
    {
      hb_svg_transform_t tr;
      tr.dx = svg_x;
      tr.dy = svg_y;
      effective.multiply (tr);
    }

    if (!suppress_viewbox_once)
    {
      float vb_x = 0.f, vb_y = 0.f, vb_w = 0.f, vb_h = 0.f;
    if (hb_raster_svg_parse_viewbox (parser.find_attr ("viewBox"),
                                     &vb_x, &vb_y, &vb_w, &vb_h))
    {
      float viewport_w = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, geom_style_props.width, "width"));
      float viewport_h = hb_raster_svg_parse_non_percent_length (svg_pick_attr_or_style (parser, geom_style_props.height, "height"));
      if (!(viewport_w > 0.f && viewport_h > 0.f))
      {
        viewport_w = vb_w;
          viewport_h = vb_h;
        }
        hb_svg_transform_t vb_t;
        if (hb_raster_svg_compute_viewbox_transform (viewport_w, viewport_h,
                                                     vb_x, vb_y, vb_w, vb_h,
                                                     parser.find_attr ("preserveAspectRatio"),
                                                     &vb_t))
          effective.multiply (vb_t);
      }
      suppress_viewbox_once = false;
    }
  }

  hb_svg_shape_emit_data_t shape;
  if (hb_raster_svg_parse_shape_tag (parser, &shape))
  {
    svg_clip_append_shape (ctx, shape, effective);
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }

  if (parser.tag_name.eq ("use"))
  {
    svg_clip_collect_use_target (ctx, parser, effective, depth + 1);
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }

  bool is_container = hb_raster_svg_tag_is_container (parser.tag_name);
  if (!is_container || parser.self_closing)
  {
    if (!parser.self_closing)
      svg_skip_subtree (parser);
    return;
  }

  int inner_depth = 1;
  while (inner_depth > 0)
  {
    hb_svg_token_type_t tok = parser.next ();
    if (tok == SVG_TOKEN_EOF) break;
    if (tok == SVG_TOKEN_CLOSE_TAG)
    {
      inner_depth--;
      continue;
    }
    if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG)
      svg_clip_collect_ref_element (ctx, parser, effective, depth + 1, false, is_visible, false);
  }
}

void
hb_raster_svg_process_clip_path_def (hb_svg_defs_t *defs,
                           hb_svg_xml_parser_t &parser,
                           hb_svg_token_type_t tok,
                           const char *doc_start,
                           unsigned doc_len,
                           const OT::SVG::accelerator_t *svg_accel,
                           const OT::SVG::svg_doc_cache_t *doc_cache)
{
  hb_svg_clip_path_def_t clip;
  hb_svg_str_t id = parser.find_attr ("id");
  hb_svg_str_t units = parser.find_attr ("clipPathUnits").trim ();
  if (units.eq_ascii_ci ("objectBoundingBox"))
    clip.units_user_space = false;
  else if (units.eq_ascii_ci ("userSpaceOnUse"))
    clip.units_user_space = true;
  else
    clip.units_user_space = true;

  hb_svg_transform_t cp_t;
  if (svg_parse_element_transform (parser, &cp_t))
  {
    clip.has_clip_transform = true;
    clip.clip_transform = cp_t;
  }

  clip.first_shape = defs->clip_shapes.length;
  clip.shape_count = 0;

  if (tok == SVG_TOKEN_OPEN_TAG)
  {
    const unsigned SVG_MAX_CLIP_DEPTH = 64;
    hb_svg_transform_t inherited[SVG_MAX_CLIP_DEPTH];
    bool inherited_visibility[SVG_MAX_CLIP_DEPTH];
    inherited[0] = hb_svg_transform_t ();
    inherited[1] = hb_svg_transform_t ();
    inherited_visibility[0] = true;
    inherited_visibility[1] = true;
    hb_decycler_t use_decycler;

    int cdepth = 1;
    bool had_alloc_failure = false;
    hb_svg_clip_collect_context_t collect_ctx = {
      defs, &clip,
      doc_start, doc_len, svg_accel, doc_cache,
      &use_decycler, &had_alloc_failure
    };
    while (cdepth > 0)
    {
      hb_svg_token_type_t ct = parser.next ();
      if (ct == SVG_TOKEN_EOF) break;
      if (ct == SVG_TOKEN_CLOSE_TAG) { cdepth--; continue; }
      if (ct == SVG_TOKEN_OPEN_TAG || ct == SVG_TOKEN_SELF_CLOSE_TAG)
      {
        if (parser.tag_name.eq ("symbol"))
        {
          if (ct == SVG_TOKEN_OPEN_TAG)
          {
            int skip_depth = 1;
            while (skip_depth > 0)
            {
              hb_svg_token_type_t st = parser.next ();
              if (st == SVG_TOKEN_EOF) break;
              if (st == SVG_TOKEN_CLOSE_TAG) skip_depth--;
              else if (st == SVG_TOKEN_OPEN_TAG) skip_depth++;
            }
          }
          continue;
        }

        if (parser.tag_name.eq ("defs"))
        {
          if (ct == SVG_TOKEN_OPEN_TAG)
          {
            int skip_depth = 1;
            while (skip_depth > 0)
            {
              hb_svg_token_type_t st = parser.next ();
              if (st == SVG_TOKEN_EOF) break;
              if (st == SVG_TOKEN_CLOSE_TAG) skip_depth--;
              else if (st == SVG_TOKEN_OPEN_TAG) skip_depth++;
            }
          }
          continue;
        }

        bool parent_visible = (unsigned) cdepth < SVG_MAX_CLIP_DEPTH
                            ? inherited_visibility[cdepth]
                            : true;
        bool is_visible = svg_resolve_element_visibility (parser, parent_visible);
        bool is_hidden = !is_visible;
        if (is_hidden)
        {
          if (ct == SVG_TOKEN_OPEN_TAG)
          {
            int skip_depth = 1;
            while (skip_depth > 0)
            {
              hb_svg_token_type_t st = parser.next ();
              if (st == SVG_TOKEN_EOF) break;
              if (st == SVG_TOKEN_CLOSE_TAG) skip_depth--;
              else if (st == SVG_TOKEN_OPEN_TAG) skip_depth++;
            }
          }
          continue;
        }

        hb_svg_transform_t effective = (unsigned) cdepth < SVG_MAX_CLIP_DEPTH
                                     ? inherited[cdepth]
                                     : hb_svg_transform_t ();

        hb_svg_transform_t local;
        bool has_local_transform = svg_parse_element_transform (parser, &local);
        if (has_local_transform)
        {
          effective.multiply (local);
        }

        if (parser.tag_name.eq ("use"))
        {
          svg_clip_collect_use_target (&collect_ctx, parser, effective, 0);
        }
        else
        {
          hb_svg_shape_emit_data_t shape;
          if (hb_raster_svg_parse_shape_tag (parser, &shape))
            svg_clip_append_shape (&collect_ctx, shape, effective);
        }

        if (ct == SVG_TOKEN_OPEN_TAG)
        {
          if ((unsigned) (cdepth + 1) < SVG_MAX_CLIP_DEPTH)
          {
            inherited[cdepth + 1] = effective;
            inherited_visibility[cdepth + 1] = is_visible;
          }
          cdepth++;
        }
      }
    }
    if (had_alloc_failure)
      id = {};
  }

  if (id.len)
    (void) defs->add_clip_path (hb_bytes_t (id.data, id.len), clip);
}

struct hb_svg_clip_emit_data_t
{
  const hb_svg_defs_t *defs;
  const hb_svg_clip_path_def_t *clip;
  hb_transform_t<> base_transform;
  hb_transform_t<> bbox_transform;
  bool has_bbox_transform = false;
};

static inline hb_transform_t<>
svg_to_hb_transform (const hb_svg_transform_t &t)
{
  return hb_transform_t<> (t.xx, t.yx, t.xy, t.yy, t.dx, t.dy);
}

static void
svg_clip_path_emit (hb_draw_funcs_t *dfuncs,
                    void *draw_data,
                    void *user_data)
{
  hb_raster_draw_t *rdr = (hb_raster_draw_t *) draw_data;
  hb_svg_clip_emit_data_t *ed = (hb_svg_clip_emit_data_t *) user_data;
  const hb_svg_clip_path_def_t *clip = ed->clip;

  for (unsigned i = 0; i < clip->shape_count; i++)
  {
    const hb_svg_clip_shape_t &s = ed->defs->clip_shapes[clip->first_shape + i];
    hb_transform_t<> t = ed->base_transform;
    if (ed->has_bbox_transform)
      t.multiply (ed->bbox_transform);
    if (clip->has_clip_transform)
      t.multiply (svg_to_hb_transform (clip->clip_transform));
    if (s.has_transform)
      t.multiply (svg_to_hb_transform (s.transform));

    hb_raster_draw_set_transform (rdr, t.xx, t.yx, t.xy, t.yy, t.x0, t.y0);

    hb_svg_shape_emit_data_t shape = s.shape;
    hb_raster_svg_shape_path_emit (dfuncs, draw_data, &shape);
  }
}

bool
hb_raster_svg_push_clip_path_ref (hb_raster_paint_t *paint,
                        hb_svg_defs_t *defs,
                        hb_svg_str_t clip_path_str,
                        const hb_extents_t<> *object_bbox)
{
  if (clip_path_str.is_null ()) return false;
  hb_svg_str_t trimmed = clip_path_str.trim ();
  if (!trimmed.len || trimmed.eq_ascii_ci ("none")) return false;

  hb_svg_str_t clip_id;
  if (!hb_raster_svg_parse_local_id_ref (trimmed, &clip_id, nullptr))
    return false;

  const hb_svg_clip_path_def_t *clip = defs->find_clip_path (hb_bytes_t (clip_id.data, clip_id.len));
  if (!clip) return false;

  hb_svg_clip_emit_data_t ed;
  ed.defs = defs;
  ed.clip = clip;
  ed.base_transform = paint->current_effective_transform ();

  if (!clip->units_user_space)
  {
    if (!object_bbox || object_bbox->is_empty ())
      return false;
    float w = object_bbox->xmax - object_bbox->xmin;
    float h = object_bbox->ymax - object_bbox->ymin;
    if (!(std::isfinite (w) && std::isfinite (h)) || w <= 0.f || h <= 0.f)
      return false;
    ed.has_bbox_transform = true;
    ed.bbox_transform = hb_transform_t<> (w, 0, 0, h, object_bbox->xmin, object_bbox->ymin);
  }

  hb_raster_paint_push_clip_path (paint, svg_clip_path_emit, &ed);
  return true;
}

#endif /* !HB_NO_RASTER_SVG */
