// Copyright (C) 2004-2021 Artifex Software, Inc.

//

// This file is part of MuPDF.

//

// MuPDF is free software: you can redistribute it and/or modify it under the

// terms of the GNU Affero General Public License as published by the Free

// Software Foundation, either version 3 of the License, or (at your option)

// any later version.

//

// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more

// details.

//

// You should have received a copy of the GNU Affero General Public License

// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>

//

// Alternative licensing terms are available from the licensor.

// For commercial licensing, see <https://www.artifex.com/> or contact

// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,

// CA 94129, USA, for further information.

#include "mupdf/fitz.h"

#include "xps-imp.h"

#include <math.h>

#include <string.h>

#define TILE

/*

 * Parse a tiling brush (visual and image brushes at this time) common

 * properties. Use the callback to draw the individual tiles.

 */

enum { TILE_NONE, TILE_TILE, TILE_FLIP_X, TILE_FLIP_Y, TILE_FLIP_X_Y };

struct closure

{

  char *base_uri;

  xps_resource *dict;

  fz_xml *root;

  void *user;

  void (*func)(fz_context *ctx, xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*);

};

static void

xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect viewbox, struct closure *c)

{

  fz_device *dev = doc->dev;

  fz_path *path;

  path = fz_new_path(ctx);

  fz_try(ctx)

  {

    fz_moveto(ctx, path, viewbox.x0, viewbox.y0);

    fz_lineto(ctx, path, viewbox.x0, viewbox.y1);

    fz_lineto(ctx, path, viewbox.x1, viewbox.y1);

    fz_lineto(ctx, path, viewbox.x1, viewbox.y0);

    fz_closepath(ctx, path);

    fz_clip_path(ctx, dev, path, 0, ctm, fz_infinite_rect);

  }

  fz_always(ctx)

    fz_drop_path(ctx, path);

  fz_catch(ctx)

    fz_rethrow(ctx);

  c->func(ctx, doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user);

  fz_pop_clip(ctx, dev);

}

static void

xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect viewbox, int tile_mode, struct closure *c)

{

  fz_matrix ttm;

  xps_paint_tiling_brush_clipped(ctx, doc, ctm, viewbox, c);

  if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)

  {

    ttm = fz_pre_scale(fz_pre_translate(ctm, viewbox.x1 * 2, 0), -1, 1);

    xps_paint_tiling_brush_clipped(ctx, doc, ttm, viewbox, c);

  }

  if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)

  {

    ttm = fz_pre_scale(fz_pre_translate(ctm, 0, viewbox.y1 * 2), 1, -1);

    xps_paint_tiling_brush_clipped(ctx, doc, ttm, viewbox, c);

  }

  if (tile_mode == TILE_FLIP_X_Y)

  {

    ttm = fz_pre_scale(fz_pre_translate(ctm, viewbox.x1 * 2, viewbox.y1 * 2), -1, -1);

    xps_paint_tiling_brush_clipped(ctx, doc, ttm, viewbox, c);

  }

}

void

xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,

  char *base_uri, xps_resource *dict, fz_xml *root,

  void (*func)(fz_context *ctx, xps_document*, fz_matrix, fz_rect, char*, xps_resource*, fz_xml*, void*), void *user)

{

  fz_device *dev = doc->dev;

  fz_xml *node;

  struct closure c;

  char *opacity_att;

  char *transform_att;

  char *viewbox_att;

  char *viewport_att;

  char *tile_mode_att;

  fz_xml *transform_tag = NULL;

  fz_rect viewbox;

  fz_rect viewport;

  float xstep, ystep;

  float xscale, yscale;

  int tile_mode;

  opacity_att = fz_xml_att(root, "Opacity");

  transform_att = fz_xml_att(root, "Transform");

  viewbox_att = fz_xml_att(root, "Viewbox");

  viewport_att = fz_xml_att(root, "Viewport");

  tile_mode_att = fz_xml_att(root, "TileMode");

  c.base_uri = base_uri;

  c.dict = dict;

  c.root = root;

  c.user = user;

  c.func = func;

  for (node = fz_xml_down(root); node; node = fz_xml_next(node))

  {

    if (fz_xml_is_tag(node, "ImageBrush.Transform"))

      transform_tag = fz_xml_down(node);

    if (fz_xml_is_tag(node, "VisualBrush.Transform"))

      transform_tag = fz_xml_down(node);

  }

  xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);

  ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);

  viewbox = fz_unit_rect;

  if (viewbox_att)

    viewbox = xps_parse_rectangle(ctx, doc, viewbox_att);

  viewport = fz_unit_rect;

  if (viewport_att)

    viewport = xps_parse_rectangle(ctx, doc, viewport_att);

  if (fabsf(viewport.x1 - viewport.x0) < 0.01f || fabsf(viewport.y1 - viewport.y0) < 0.01f)

    fz_warn(ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0);

  else if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f || fabsf(viewbox.y1 - viewbox.y0) < 0.01f)

    fz_warn(ctx, "not drawing tile for viewbox size %.4f x %.4f", viewbox.x1 - viewbox.x0, viewbox.y1 - viewbox.y0);

  /* some sanity checks on the viewport/viewbox size */

  if (fabsf(viewport.x1 - viewport.x0) < 0.01f) return;

  if (fabsf(viewport.y1 - viewport.y0) < 0.01f) return;

  if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f) return;

  if (fabsf(viewbox.y1 - viewbox.y0) < 0.01f) return;

  xstep = viewbox.x1 - viewbox.x0;

  ystep = viewbox.y1 - viewbox.y0;

  xscale = (viewport.x1 - viewport.x0) / xstep;

  yscale = (viewport.y1 - viewport.y0) / ystep;

  tile_mode = TILE_NONE;

  if (tile_mode_att)

  {

    if (!strcmp(tile_mode_att, "None"))

      tile_mode = TILE_NONE;

    if (!strcmp(tile_mode_att, "Tile"))

      tile_mode = TILE_TILE;

    if (!strcmp(tile_mode_att, "FlipX"))

      tile_mode = TILE_FLIP_X;

    if (!strcmp(tile_mode_att, "FlipY"))

      tile_mode = TILE_FLIP_Y;

    if (!strcmp(tile_mode_att, "FlipXY"))

      tile_mode = TILE_FLIP_X_Y;

  }

  if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)

    xstep *= 2;

  if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)

    ystep *= 2;

  xps_begin_opacity(ctx, doc, ctm, area, base_uri, dict, opacity_att, NULL);

  ctm = fz_pre_translate(ctm, viewport.x0, viewport.y0);

  ctm = fz_pre_scale(ctm, xscale, yscale);

  ctm = fz_pre_translate(ctm, -viewbox.x0, -viewbox.y0);

  if (tile_mode != TILE_NONE)

  {

    int x0, y0, x1, y1;

    fz_matrix invctm;

    invctm = fz_invert_matrix(ctm);

    area = fz_transform_rect(area, invctm);

    x0 = floorf(area.x0 / xstep);

    y0 = floorf(area.y0 / ystep);

    x1 = ceilf(area.x1 / xstep);

    y1 = ceilf(area.y1 / ystep);

#ifdef TILE

    if ((x1 - x0) * (y1 - y0) > 1)

#else

    if (0)

#endif

    {

      fz_rect bigview = viewbox;

      bigview.x1 = bigview.x0 + xstep;

      bigview.y1 = bigview.y0 + ystep;

      fz_begin_tile(ctx, dev, area, bigview, xstep, ystep, ctm);

      xps_paint_tiling_brush(ctx, doc, ctm, viewbox, tile_mode, &c);

      fz_end_tile(ctx, dev);

    }

    else

    {

      int x, y;

      for (y = y0; y < y1; y++)

      {

        for (x = x0; x < x1; x++)

        {

          fz_matrix ttm = fz_pre_translate(ctm, xstep * x, ystep * y);

          xps_paint_tiling_brush(ctx, doc, ttm, viewbox, tile_mode, &c);

        }

      }

    }

  }

  else

  {

    xps_paint_tiling_brush(ctx, doc, ctm, viewbox, tile_mode, &c);

  }

  xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL);

}

static void

xps_paint_visual_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,

  char *base_uri, xps_resource *dict, fz_xml *root, void *visual_tag)

{

  xps_parse_element(ctx, doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag);

}

void

xps_parse_visual_brush(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area,

  char *base_uri, xps_resource *dict, fz_xml *root)

{

  fz_xml *node;

  char *visual_uri;

  char *visual_att;

  fz_xml *visual_tag = NULL;

  visual_att = fz_xml_att(root, "Visual");

  for (node = fz_xml_down(root); node; node = fz_xml_next(node))

  {

    if (fz_xml_is_tag(node, "VisualBrush.Visual"))

      visual_tag = fz_xml_down(node);

  }

  visual_uri = base_uri;

  xps_resolve_resource_reference(ctx, doc, dict, &visual_att, &visual_tag, &visual_uri);

  if (visual_tag)

  {

    xps_parse_tiling_brush(ctx, doc, ctm, area,

      visual_uri, dict, root, xps_paint_visual_brush, visual_tag);

  }

}

void

xps_parse_canvas(fz_context *ctx, xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, fz_xml *root)

{

  fz_device *dev = doc->dev;

  xps_resource *new_dict = NULL;

  fz_xml *node;

  char *opacity_mask_uri;

  char *transform_att;

  char *clip_att;

  char *opacity_att;

  char *opacity_mask_att;

  fz_xml *transform_tag = NULL;

  fz_xml *clip_tag = NULL;

  fz_xml *opacity_mask_tag = NULL;

  transform_att = fz_xml_att(root, "RenderTransform");

  clip_att = fz_xml_att(root, "Clip");

  opacity_att = fz_xml_att(root, "Opacity");

  opacity_mask_att = fz_xml_att(root, "OpacityMask");

  for (node = fz_xml_down(root); node; node = fz_xml_next(node))

  {

    if (fz_xml_is_tag(node, "Canvas.Resources") && fz_xml_down(node))

    {

      if (new_dict)

      {

        fz_warn(ctx, "ignoring follow-up resource dictionaries");

      }

      else

      {

        new_dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node));

        if (new_dict)

        {

          new_dict->parent = dict;

          dict = new_dict;

        }

      }

    }

    if (fz_xml_is_tag(node, "Canvas.RenderTransform"))

      transform_tag = fz_xml_down(node);

    if (fz_xml_is_tag(node, "Canvas.Clip"))

      clip_tag = fz_xml_down(node);

    if (fz_xml_is_tag(node, "Canvas.OpacityMask"))

      opacity_mask_tag = fz_xml_down(node);

  }

  fz_try(ctx)

  {

    opacity_mask_uri = base_uri;

    xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);

    xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL);

    xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri);

    ctm = xps_parse_transform(ctx, doc, transform_att, transform_tag, ctm);

    if (clip_att || clip_tag)

      xps_clip(ctx, doc, ctm, dict, clip_att, clip_tag);

    xps_begin_opacity(ctx, doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);

    for (node = fz_xml_down(root); node; node = fz_xml_next(node))

      xps_parse_element(ctx, doc, ctm, area, base_uri, dict, node);

    xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);

    if (clip_att || clip_tag)

      fz_pop_clip(ctx, dev);

  }

  fz_always(ctx)

    xps_drop_resource_dictionary(ctx, doc, new_dict);

  fz_catch(ctx)

    fz_rethrow(ctx);

}

void

xps_parse_fixed_page(fz_context *ctx, xps_document *doc, fz_matrix ctm, xps_page *page)

{

  fz_xml *root, *node;

  xps_resource *dict;

  char base_uri[1024];

  fz_rect area;

  char *s;

  fz_strlcpy(base_uri, page->fix->name, sizeof base_uri);

  s = strrchr(base_uri, '/');

  if (s)

    s[1] = 0;

  dict = NULL;

  doc->opacity_top = 0;

  doc->opacity[0] = 1;

  root = fz_xml_root(page->xml);

  if (!root)

    return;

  area = fz_transform_rect(fz_unit_rect, fz_scale(page->fix->width, page->fix->height));

  fz_try(ctx)

  {

    for (node = fz_xml_down(root); node; node = fz_xml_next(node))

    {

      if (fz_xml_is_tag(node, "FixedPage.Resources") && fz_xml_down(node))

      {

        if (dict)

          fz_warn(ctx, "ignoring follow-up resource dictionaries");

        else

          dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node));

      }

      xps_parse_element(ctx, doc, ctm, area, base_uri, dict, node);

    }

  }

  fz_always(ctx)

    xps_drop_resource_dictionary(ctx, doc, dict);

  fz_catch(ctx)

    fz_rethrow(ctx);

}

void

xps_run_page(fz_context *ctx, fz_page *page_, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)

{

  xps_page *page = (xps_page*)page_;

  xps_document *doc = (xps_document*)page->super.doc;

  fz_matrix page_ctm;

  page_ctm = fz_pre_scale(ctm, 72.0f / 96.0f, 72.0f / 96.0f);

  doc->cookie = cookie;

  doc->dev = dev;

  xps_parse_fixed_page(ctx, doc, page_ctm, page);

  doc->cookie = NULL;

  doc->dev = NULL;

}