#!/usr/bin/env python
# coding=utf-8
#
# Copyright (C) 2007 Tavmjong Bah, tavmjong@free.fr
# Copyright (C) 2006 Georg Wiora, xorx@quarkbox.de
# Copyright (C) 2006 Johan Engelen, johan@shouraizou.nl
# Copyright (C) 2005 Aaron Spike, aaron@ekips.org
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# Changes:
#  * This program is a modified version of wavy.py by Aaron Spike.
#  * 22-Dec-2006: Wiora : Added axis and isotropic scaling
#  * 21-Jun-2007: Tavmjong: Added polar coordinates
#
from math import cos, pi, sin

import inkex
from inkex import ClipPath, Rectangle
from inkex.utils import math_eval

from inkex.localization import inkex_gettext as _


def drawfunction(
    xstart,
    xend,
    ybottom,
    ytop,
    samples,
    width,
    height,
    left,
    bottom,
    fx="sin(x)",
    fpx="cos(x)",
    fponum=True,
    times2pi=False,
    polar=False,
    isoscale=True,
    drawaxis=True,
    endpts=False,
):
    if times2pi:
        xstart = 2 * pi * xstart
        xend = 2 * pi * xend

    # coords and scales based on the source rect
    if xstart == xend:
        inkex.errormsg(
            _(
                "x-interval cannot be zero. Please modify 'Start X value' "
                "or 'End X value'"
            )
        )
        return []
    scalex = width / (xend - xstart)
    xoff = left
    coordx = lambda x: (x - xstart) * scalex + xoff  # convert x-value to coordinate
    if polar:  # Set scale so that left side of rectangle is -1, right side is +1.
        # (We can't use xscale for both range and scale.)
        centerx = left + width / 2.0
        polar_scalex = width / 2.0
        coordx = lambda x: x * polar_scalex + centerx  # convert x-value to coordinate

    if ytop == ybottom:
        inkex.errormsg(
            _(
                "y-interval cannot be zero. Please modify 'Y value of rectangle's top' "
                "or 'Y value of rectangle's bottom'"
            )
        )
        return []
    scaley = height / (ytop - ybottom)
    yoff = bottom
    coordy = lambda y: (ybottom - y) * scaley + yoff  # convert y-value to coordinate

    # Check for isotropic scaling and use smaller of the two scales, correct ranges
    if isoscale and not polar:
        if scaley < scalex:
            # compute zero location
            xzero = coordx(0)
            # set scale
            scalex = scaley
            # correct x-offset
            xstart = (left - xzero) / scalex
            xend = (left + width - xzero) / scalex
        else:
            # compute zero location
            yzero = coordy(0)
            # set scale
            scaley = scalex
            # correct x-offset
            ybottom = (yzero - bottom) / scaley
            ytop = (bottom + height - yzero) / scaley

    f = math_eval(fx)
    fp = math_eval(fpx)
    if f is None or (fp is None and not (fponum)):
        raise inkex.AbortExtension(_("Invalid function specification"))

    # step is the distance between nodes on x
    step = (xend - xstart) / (samples - 1)
    third = step / 3.0
    ds = step * 0.001  # Step used in calculating derivatives

    a = []  # path array
    # add axis
    if drawaxis:
        # check for visibility of x-axis
        if ybottom <= 0 <= ytop:
            # xaxis
            a.append(["M", [left, coordy(0)]])
            a.append(["l", [width, 0]])
        # check for visibility of y-axis
        if xstart <= 0 <= xend:
            # xaxis
            a.append(["M", [coordx(0), bottom]])
            a.append(["l", [0, -height]])

    # initialize function and derivative for 0;
    # they are carried over from one iteration to the next, to avoid extra function calculations.
    x0 = xstart
    y0 = f(xstart)
    if polar:
        xp0 = y0 * cos(x0)
        yp0 = y0 * sin(x0)
        x0 = xp0
        y0 = yp0
    if (
        fponum or polar
    ):  # numerical derivative, using 0.001*step as the small differential
        x1 = xstart + ds  # Second point AFTER first point (Good for first point)
        y1 = f(x1)
        if polar:
            xp1 = y1 * cos(x1)
            yp1 = y1 * sin(x1)
            x1 = xp1
            y1 = yp1
        dx0 = (x1 - x0) / ds
        dy0 = (y1 - y0) / ds
    else:  # derivative given by the user
        dx0 = 1  # Only works for rectangular coordinates
        dy0 = fp(xstart)

    # Start curve
    if endpts:
        a.append(["M", [left, coordy(0)]])
        a.append(["L", [coordx(x0), coordy(y0)]])
    else:
        a.append(["M", [coordx(x0), coordy(y0)]])  # initial moveto

    for i in range(int(samples - 1)):
        x1 = (i + 1) * step + xstart
        x2 = x1 - ds  # Second point BEFORE first point (Good for last point)
        y1 = f(x1)
        y2 = f(x2)
        if polar:
            xp1 = y1 * cos(x1)
            yp1 = y1 * sin(x1)
            xp2 = y2 * cos(x2)
            yp2 = y2 * sin(x2)
            x1 = xp1
            y1 = yp1
            x2 = xp2
            y2 = yp2
        if fponum or polar:  # numerical derivative
            dx1 = (x1 - x2) / ds
            dy1 = (y1 - y2) / ds
        else:  # derivative given by the user
            dx1 = 1  # Only works for rectangular coordinates
            dy1 = fp(x1)
        # create curve
        a.append(
            [
                "C",
                [
                    coordx(x0 + (dx0 * third)),
                    coordy(y0 + (dy0 * third)),
                    coordx(x1 - (dx1 * third)),
                    coordy(y1 - (dy1 * third)),
                    coordx(x1),
                    coordy(y1),
                ],
            ]
        )
        x0 = x1  # Next segment's start is this segments end
        y0 = y1
        dx0 = dx1  # Assume the function is smooth everywhere, so carry over the derivative too
        dy0 = dy1
    if endpts:
        a.append(["L", [left + width, coordy(0)]])
    return a


class FuncPlot(inkex.EffectExtension):
    def add_arguments(self, pars):
        pars.add_argument("--tab")
        pars.add_argument("--xstart", type=float, default=0.0, help="Start x-value")
        pars.add_argument("--xend", type=float, default=1.0, help="End x-value")
        pars.add_argument(
            "--times2pi", type=inkex.Boolean, default=False, help="* x-range by 2*pi"
        )
        pars.add_argument(
            "--polar", type=inkex.Boolean, default=False, help="Use polar coords"
        )
        pars.add_argument(
            "--ybottom", type=float, default=0.0, help="y-value of rect's bottom"
        )
        pars.add_argument(
            "--ytop", type=float, default=1.0, help="y-value of rectangle's top"
        )
        pars.add_argument("--samples", type=int, default=8, help="Samples")
        pars.add_argument("--fofx", default="sin(x)", help="f(x) for plotting")
        pars.add_argument(
            "--fponum", type=inkex.Boolean, default=True, help="Numerical 1st deriv"
        )
        pars.add_argument("--fpofx", default="cos(x)", help="f'(x) for plotting")
        pars.add_argument(
            "--clip", type=inkex.Boolean, default=False, help="Clip with source rect"
        )
        pars.add_argument(
            "--remove", type=inkex.Boolean, default=True, help="Remove source rect"
        )
        pars.add_argument(
            "--isoscale", type=inkex.Boolean, default=True, help="Isotropic scaling"
        )
        pars.add_argument(
            "--drawaxis", type=inkex.Boolean, default=False, help="Draw axis"
        )
        pars.add_argument(
            "--endpts", type=inkex.Boolean, default=False, help="Add end points"
        )

    def effect(self):
        newpath = None
        for node in self.svg.selection.values():
            if isinstance(node, Rectangle):
                # create new path with basic dimensions of selected rectangle
                newpath = inkex.PathElement()
                x = float(node.get("x"))
                y = float(node.get("y"))
                w = float(node.get("width"))
                h = float(node.get("height"))

                # copy attributes of rect
                newpath.style = node.style
                newpath.transform = node.transform

                # top and bottom were exchanged
                newpath.path = drawfunction(
                    self.options.xstart,
                    self.options.xend,
                    self.options.ybottom,
                    self.options.ytop,
                    self.options.samples,
                    w,
                    h,
                    x,
                    y + h,
                    self.options.fofx,
                    self.options.fpofx,
                    self.options.fponum,
                    self.options.times2pi,
                    self.options.polar,
                    self.options.isoscale,
                    self.options.drawaxis,
                    self.options.endpts,
                )
                newpath.set("title", self.options.fofx)

                # add path into SVG structure
                node.getparent().append(newpath)
                # option whether to clip the path with rect or not.
                if self.options.clip:
                    clip = self.svg.defs.add(ClipPath())
                    clip.set_random_id()
                    clip.append(node.copy())
                    newpath.set("clip-path", clip.get_id(as_url=2))
                # option whether to remove the rectangle or not.
                if self.options.remove:
                    node.getparent().remove(node)
        if newpath is None:
            raise inkex.AbortExtension(_("Please select a rectangle"))


if __name__ == "__main__":
    FuncPlot().run()