#!/usr/bin/env python
#
# A Diagram base class
#
# Copyright (C) 2018  Antonio Ospite <ao2@ao2.it>
#
# 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 3 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, see <http://www.gnu.org/licenses/>.

from math import cos, sin, pi, fmod


class Diagram(object):
    def __init__(self, width, height, background=(1, 1, 1), font_size=20, stroke_width=2):
        self.width = width
        self.height = height
        self.background = background
        self.font_size = font_size
        self.stroke_width = stroke_width

    def clear(self):
        raise NotImplementedError

    @staticmethod
    def color_to_rgba(color):
        assert len(color) >= 3

        color = tuple(float(c) for c in color)
        if len(color) == 3:
            color += (1.0,)

        return color

    @staticmethod
    def normalized_angle_01(theta):
        return fmod(theta, 2 * pi) / (2 * pi)

    @staticmethod
    def get_regular_polygon(x, y, sides, r, theta0=0.0):
        """Calc the coordinates of the regular polygon.

        NOTE: the first point will be in axis with y."""
        theta = 2 * pi / sides

        verts = []
        for i in range(sides):
            px = x + r * sin(theta0 + i * theta)
            py = y + r * cos(theta0 + i * theta)
            verts.append((px, py))

        return verts

    def draw_polygon_by_verts(self, verts,
                              stroke_color=(0, 0, 0),
                              fill_color=None):
        raise NotImplementedError

    def draw_regular_polygon(self, cx, cy, sides, r, theta=0.0,
                             stroke_color=(0, 0, 0),
                             fill_color=None):
        verts = self.get_regular_polygon(cx, cy, sides, r, theta)
        self.draw_polygon_by_verts(verts, stroke_color, fill_color)
        return verts

    def draw_star_by_verts(self, cx, cy, verts, stroke_color=(0, 0, 0)):
        raise NotImplementedError

    def draw_star(self, cx, cy, sides, r, theta=0.0, stroke_color=(0, 0, 0)):
        verts = self.get_regular_polygon(cx, cy, sides, r, theta)
        self.draw_star_by_verts(cx, cy, verts, stroke_color)
        return verts

    def draw_apothem_star(self, cx, cy, sides, r, theta=0.0, stroke_color=(0, 0, 0)):
        """Draw a star but calculate the regular polygon apothem from the passed radius."""
        apothem = r * cos(pi / sides)
        apothem_angle = theta + pi / sides

        return self.draw_star(cx, cy, sides, apothem, apothem_angle, stroke_color)

    def draw_rect(self, x, y, width, height, theta=0,
                  stroke_color=None,
                  fill_color=(1, 1, 1, 0.8)):
        raise NotImplementedError

    def draw_rect_from_center(self, cx, cy, width, height, theta=0.0,
                              stroke_color=None,
                              fill_color=(1, 1, 1, 0.8)):
        # the position of the center of a rectangle at (0,0)
        mx = width / 2.0
        my = height / 2.0

        # calculate the position of the bottom-left corner after rotating the
        # rectangle around the center
        rx = cx - (mx * cos(theta) - my * sin(theta))
        ry = cy - (mx * sin(theta) + my * cos(theta))

        self.draw_rect(rx, ry, width, height, theta, stroke_color, fill_color)