#!/usr/bin/env python

import numpy as np
import itertools as it
from copy import deepcopy
import sys

from big_ol_pile_of_manim_imports import *

ARROW_CONFIG = {"stroke_width" : 2*DEFAULT_STROKE_WIDTH}
LIGHT_RED = RED_E

def matrix_to_string(matrix):
    return "--".join(["-".join(map(str, row)) for row in matrix])

def matrix_mobject(matrix):
    return TextMobject(
        """
        \\left(
            \\begin{array}{%s}
                %d & %d \\\\
                %d & %d
            \\end{array}
        \\right)
        """%tuple(["c"*matrix.shape[1]] + list(matrix.flatten())),
        size = "\\Huge"
    )

class ShowMultiplication(NumberLineScene):
    args_list = [
        (2, True),
        (0.5, True),
        (-3, True),
        (-3, True),
        (2, True),
        (6, True),
    ]
    @staticmethod
    def args_to_string(num, show_original_line):
        end_string = "WithCopiedOriginalLine" if show_original_line else ""
        return str(num) + end_string
    @staticmethod
    def string_to_args(string):
        parts = string.split()
        if len(parts) == 2:
            num, original_line = parts
            show_original_line = original_line == "WithCopiedOriginalLine"
            return float(num), False
        else:
            return float(parts[0]), False

    def construct(self, num, show_original_line):
        config = {
            "density" : max(abs(num), 1)*DEFAULT_POINT_DENSITY_1D,
            "stroke_width" : 2*DEFAULT_STROKE_WIDTH
        }
        if abs(num) < 1:
            config["numerical_radius"] = FRAME_X_RADIUS/num

        NumberLineScene.construct(self, **config)
        if show_original_line:
            self.copy_original_line()
        self.wait()
        self.show_multiplication(num, run_time = 1.5)
        self.wait()

    def copy_original_line(self):
        copied_line = deepcopy(self.number_line)
        copied_num_mobs = deepcopy(self.number_mobs)
        self.play(
            ApplyFunction(
                lambda m : m.shift(DOWN).set_color("lightgreen"), 
                copied_line
            ), *[
                ApplyMethod(mob.shift, DOWN)
                for mob in copied_num_mobs
            ]
        )
        self.wait()

class ExamplesOfOneDimensionalLinearTransforms(ShowMultiplication):
    args_list = []
    @staticmethod
    def args_to_string():
        return ""

    def construct(self):
        for num in [2, 0.5, -3]:
            self.clear()            
            ShowMultiplication.construct(self, num, False)



class ExamplesOfNonlinearOneDimensionalTransforms(NumberLineScene):
    def construct(self):
        def sinx_plux_x(x_y_z):
            (x, y, z) = x_y_z
            return (np.sin(x) + 1.2*x, y, z)

        def shift_zero(x_y_z):
            (x, y, z) = x_y_z
            return (2*x+4, y, z)

        self.nonlinear = TextMobject("Not a Linear Transform")
        self.nonlinear.set_color(LIGHT_RED).to_edge(UP, buff = 1.5)
        pairs = [
            (sinx_plux_x, "numbers don't remain evenly spaced"),
            (shift_zero, "zero does not remain fixed")
        ]
        for func, explanation in pairs:
            self.run_function(func, explanation)
            self.wait(3)

    def run_function(self, function, explanation):
        self.clear()
        self.add(self.nonlinear)
        config = {
            "stroke_width" : 2*DEFAULT_STROKE_WIDTH,
            "density" : 5*DEFAULT_POINT_DENSITY_1D,
        }
        NumberLineScene.construct(self, **config)
        words = TextMobject(explanation).set_color(LIGHT_RED)
        words.next_to(self.nonlinear, DOWN, buff = 0.5)
        self.add(words)

        self.play(
            ApplyPointwiseFunction(function, self.number_line),
            *[
                ApplyMethod(
                    mob.shift,
                    function(mob.get_center()) - mob.get_center()
                )
                for mob in self.number_mobs
            ],
            run_time = 2.0
        )


class ShowTwoThenThree(ShowMultiplication):
    args_list = []
    @staticmethod
    def args_to_string():
        return ""

    def construct(self):
        config = {
            "stroke_width" : 2*DEFAULT_STROKE_WIDTH,
            "density" : 6*DEFAULT_POINT_DENSITY_1D,
        }
        NumberLineScene.construct(self, **config)
        self.copy_original_line()
        self.show_multiplication(2)
        self.wait()
        self.show_multiplication(3)
        self.wait()


########################################################

class TransformScene2D(Scene):
    def add_number_plane(self, density_factor = 1, use_faded_lines = True):
        config = {
            "x_radius" : FRAME_WIDTH,
            "y_radius" : FRAME_WIDTH,
            "density" : DEFAULT_POINT_DENSITY_1D*density_factor,
            "stroke_width" : 2*DEFAULT_STROKE_WIDTH
        }
        if not use_faded_lines:
            config["x_faded_line_frequency"] = None
            config["y_faded_line_frequency"] = None
        self.number_plane = NumberPlane(**config)
        self.add(self.number_plane)

    def add_background(self):
        grey_plane = NumberPlane(color = "grey")
        num_mobs = grey_plane.get_coordinate_labels()
        self.paint_into_background(grey_plane, *num_mobs)

    def add_x_y_arrows(self):
        self.x_arrow = Arrow(
            ORIGIN, 
            self.number_plane.num_pair_to_point((1, 0)),
            color = "lightgreen",
            **ARROW_CONFIG
        )
        self.y_arrow = Arrow(
            ORIGIN,
            self.number_plane.num_pair_to_point((0, 1)),
            color = LIGHT_RED,
            **ARROW_CONFIG
        )
        self.add(self.x_arrow, self.y_arrow)
        self.number_plane.filter_out(
            lambda x_y_z : (0 < x_y_z[0]) and (x_y_z[0] < 1) and (abs(x_y_z[1]) < 0.1)
        )
        self.number_plane.filter_out(
            lambda x_y_z1 : (0 < x_y_z1[1]) and (x_y_z1[1] < 1) and (abs(x_y_z1[0]) < 0.1)
        )
        return self


class ShowMatrixTransform(TransformScene2D):
    args_list = [
        ([[1, 3], [-2, 0]], False, False),
        ([[1, 3], [-2, 0]], True, False),
        ([[1, 0.5], [0.5, 1]], True, False),
        ([[2, 0], [0, 2]], True, False),
        ([[0.5, 0], [0, 0.5]], True, False),
        ([[-1, 0], [0, -1]], True, False),
        ([[0, 1], [1, 0]], True, False),
        ([[-2, 0], [-1, -1]], True, False),
        ([[0, -1], [1, 0]], True, False),
    ]
    @staticmethod
    def args_to_string(matrix, with_background, show_matrix):
        background_string = "WithBackground" if with_background else "WithoutBackground"
        show_string = "ShowingMatrix" if show_matrix else ""
        return matrix_to_string(matrix) + background_string + show_string

    def construct(self, matrix, with_background, show_matrix):
        matrix = np.array(matrix)
        number_plane_config = {
            "density_factor" : self.get_density_factor(matrix)
        }
        if with_background:
            self.add_background()
            number_plane_config["use_faded_lines"] = False
            self.add_number_plane(**number_plane_config)
            self.add_x_y_arrows()
        else:
            self.add_number_plane(**number_plane_config)
        if show_matrix:
            self.add(matrix_mobject(matrix).to_corner(UP+LEFT))
        def func(mobject):
            mobject.points[:, :2] = np.dot(mobject.points[:, :2], np.transpose(matrix))
            return mobject

        self.wait()
        kwargs = {
            "run_time" : 2.0,
            "path_func" : self.get_path_func(matrix)
        }
        anims = [ApplyFunction(func, self.number_plane, **kwargs)]
        if hasattr(self, "x_arrow") and hasattr(self, "y_arrow"):
            for arrow, index in (self.x_arrow, 0), (self.y_arrow, 1):
                new_arrow = Arrow(
                    ORIGIN,
                    self.number_plane.num_pair_to_point(matrix[:,index]),
                    color = arrow.get_color(),
                    **ARROW_CONFIG
                )
                arrow.remove_tip()
                new_arrow.remove_tip()
                Mobject.align_data(arrow, new_arrow)
                arrow.add_tip()
                new_arrow.add_tip()
                anims.append(Transform(arrow, new_arrow, **kwargs))
        self.play(*anims)
        self.wait()

    def get_density_factor(self, matrix):
        max_norm = max([
            abs(get_norm(column))
            for column in np.transpose(matrix)
        ])
        return max(max_norm, 1)

    def get_path_func(self, matrix):
        rotational_components = np.array([
            np.log(multiplier*complex(*matrix[:,i])).imag
            for i, multiplier in [(0, 1), (1, complex(0, -1))]
        ])
        rotational_components[rotational_components == -np.pi] = np.pi
        return path_along_arc(np.mean(rotational_components))


class ExamplesOfTwoDimensionalLinearTransformations(ShowMatrixTransform):
    args_list = []
    @staticmethod
    def args_to_string():
        return ""

    def construct(self):
        matrices = [
            [[1, 0.5], 
             [0.5, 1]],
            [[0, -1],
             [2, 0]],
            [[1, 3],
             [-2, 0]],
        ]
        for matrix in matrices:
            self.clear()
            ShowMatrixTransform.construct(self, matrix, False, False)


class ExamplesOfNonlinearTwoDimensionalTransformations(Scene):
    def construct(self):
        Scene.construct(self)
        def squiggle(x_y_z):
            (x, y, z) = x_y_z
            return (x+np.sin(y), y+np.cos(x), z)

        def shift_zero(x_y_z):
            (x, y, z) = x_y_z
            return (2*x + 3*y + 4, -1*x+y+2, z)

        self.nonlinear = TextMobject("Nonlinear Transform")
        self.nonlinear.set_color(LIGHT_RED)
        self.nonlinear.to_edge(UP, buff = 1.5)
        pairs = [
            (squiggle, "lines do not remain straight"),
            (shift_zero, "the origin does not remain fixed")
        ]
        self.get_blackness()
        for function, explanation in pairs:
            self.apply_function(function, explanation)


    def apply_function(self, function, explanation):
        self.clear()
        config = {
            "x_radius" : FRAME_WIDTH,
            "y_radius" : FRAME_WIDTH,
            "density" : 3*DEFAULT_POINT_DENSITY_1D,
            "stroke_width" : 2*DEFAULT_STROKE_WIDTH
        }
        number_plane = NumberPlane(**config)
        numbers = number_plane.get_coordinate_labels()
        words = TextMobject(explanation)
        words.set_color(LIGHT_RED)
        words.next_to(self.nonlinear, DOWN, buff = 0.5)

        self.add(number_plane, *numbers)
        self.add(self.blackness, self.nonlinear, words)
        self.wait()
        self.play(
            ApplyPointwiseFunction(function, number_plane),
            *[
                ApplyMethod(
                    mob.shift,
                    function(mob.get_center())-mob.get_center()
                )
                for mob in numbers
            ] + [
                Animation(self.blackness),
                Animation(words),
                Animation(self.nonlinear)
            ],
            run_time = 2.0
        )
        self.wait(3)

    def get_blackness(self):
        vertices = [
            3.5*LEFT+1.05*UP,
            3.5*RIGHT+1.05*UP,
            3.5*RIGHT+2.75*UP,
            3.5*LEFT+2.75*UP,
        ]

        region = region_from_polygon_vertices(*vertices)
        image = disp.paint_region(region, color = WHITE)
        self.blackness = TextMobject("")
        ImageMobject.generate_points_from_image_array(self.blackness, image)
        self.blackness.set_color(BLACK)
        rectangle = Rectangle(width = 7, height=1.7)
        rectangle.set_color(WHITE)
        rectangle.shift(self.blackness.get_center())
        self.blackness.add(rectangle)
        self.blackness.scale_in_place(0.95)


class TrickyExamplesOfNonlinearTwoDimensionalTransformations(Scene):
    def construct(self):
        config = {
            "x_radius" : 0.6*FRAME_WIDTH,
            "y_radius" : 0.6*FRAME_WIDTH,
            "density" : 10*DEFAULT_POINT_DENSITY_1D,
            "stroke_width" : 2*DEFAULT_STROKE_WIDTH
        }
        number_plane = NumberPlane(**config)
        phrase1, phrase2 = TextMobject([
            "These might look like they keep lines straight...",
            "but diagonal lines get curved"
        ]).to_edge(UP, buff = 1.5).split()
        phrase2.set_color(LIGHT_RED)
        diagonal = Line(
            DOWN*FRAME_Y_RADIUS+LEFT*FRAME_X_RADIUS,
            UP*FRAME_Y_RADIUS+RIGHT*FRAME_X_RADIUS,
            density = 10*DEFAULT_POINT_DENSITY_1D
        )

        def sunrise(x_y_z):
            (x, y, z) = x_y_z
            return ((FRAME_Y_RADIUS+y)*x, y, z)

        def squished(x_y_z):
            (x, y, z) = x_y_z
            return (x + np.sin(x), y+np.sin(y), z)

        self.get_blackness()

        self.run_function(sunrise, number_plane, phrase1)
        self.run_function(squished, number_plane, phrase1)
        phrase1.add(phrase2)
        self.add(phrase1)
        self.play(ShowCreation(diagonal))
        self.remove(diagonal)
        number_plane.add(diagonal)
        self.run_function(sunrise, number_plane, phrase1)
        self.run_function(squished, number_plane, phrase1, False)


    def run_function(self, function, plane, phrase, remove_plane = True):
        number_plane = deepcopy(plane)
        self.add(number_plane, self.blackness, phrase)
        self.wait()
        self.play(
            ApplyPointwiseFunction(function, number_plane, run_time = 2.0),
            Animation(self.blackness),            
            Animation(phrase),
        )
        self.wait(3)
        if remove_plane:
            self.remove(number_plane)

    def get_blackness(self):
        vertices = [
            4.5*LEFT+1.25*UP,
            4.5*RIGHT+1.25*UP,
            4.5*RIGHT+2.75*UP,
            4.5*LEFT+2.75*UP,
        ]

        region = region_from_polygon_vertices(*vertices)
        image = disp.paint_region(region, color = WHITE)
        self.blackness = TextMobject("")
        ImageMobject.generate_points_from_image_array(self.blackness, image)
        self.blackness.set_color(BLACK)
        rectangle = Rectangle(width = 9, height=1.5)
        rectangle.set_color(WHITE)
        rectangle.shift(self.blackness.get_center())
        self.blackness.add(rectangle)
        self.blackness.scale_in_place(0.95)


############# HORRIBLE! ##########################
class ShowMatrixTransformWithDot(TransformScene2D):
    args_list = [
        ([[1, 3], [-2, 0]], True, False),
    ]
    @staticmethod
    def args_to_string(matrix, with_background, show_matrix):
        background_string = "WithBackground" if with_background else "WithoutBackground"
        show_string = "ShowingMatrix" if show_matrix else ""
        return matrix_to_string(matrix) + background_string + show_string

    def construct(self, matrix, with_background, show_matrix):
        matrix = np.array(matrix)
        number_plane_config = {
            "density_factor" : self.get_density_factor(matrix),
        }
        if with_background:
            self.add_background()
            number_plane_config["use_faded_lines"] = False
            self.add_number_plane(**number_plane_config)
            self.add_x_y_arrows()
        else:
            self.add_number_plane(**number_plane_config)
        if show_matrix:
            self.add(matrix_mobject(matrix).to_corner(UP+LEFT))
        def func(mobject):
            mobject.points[:, :2] = np.dot(mobject.points[:, :2], np.transpose(matrix))
            return mobject
        dot = Dot((-1, 2, 0), color = "yellow")
        self.add(dot)
        x_arrow_copy = deepcopy(self.x_arrow)
        y_arrow_copy = Arrow(LEFT, LEFT+2*UP, color = LIGHT_RED, **ARROW_CONFIG)

        self.play(ApplyMethod(x_arrow_copy.rotate, np.pi))
        self.play(ShowCreation(y_arrow_copy))
        self.wait()
        self.remove(x_arrow_copy, y_arrow_copy)
        kwargs = {
            "run_time" : 2.0,
            "path_func" : self.get_path_func(matrix)
        }
        anims = [
            ApplyFunction(func, self.number_plane, **kwargs),
            ApplyMethod(dot.shift, func(deepcopy(dot)).get_center()-dot.get_center(), **kwargs),
        ]
        if hasattr(self, "x_arrow") and hasattr(self, "y_arrow"):
            for arrow, index in (self.x_arrow, 0), (self.y_arrow, 1):
                new_arrow = Arrow(
                    ORIGIN,
                    self.number_plane.num_pair_to_point(matrix[:,index]),
                    color = arrow.get_color(),
                    **ARROW_CONFIG
                )
                arrow.remove_tip()
                new_arrow.remove_tip()
                Mobject.align_data(arrow, new_arrow)
                arrow.add_tip()
                new_arrow.add_tip()
                anims.append(Transform(arrow, new_arrow, **kwargs))
        self.play(*anims)
        self.wait()

        x_arrow_copy = deepcopy(self.x_arrow)
        y_arrow_copy = Arrow(LEFT+2*UP, 5*RIGHT+2*UP, color = LIGHT_RED, **ARROW_CONFIG)
        self.play(ApplyMethod(x_arrow_copy.rotate, np.pi))
        self.play(ShowCreation(y_arrow_copy))
        self.wait(3)
        self.remove(x_arrow_copy, y_arrow_copy)        

    def get_density_factor(self, matrix):
        max_norm = max([
            abs(get_norm(column))
            for column in np.transpose(matrix)
        ])
        return max(max_norm, 1)

    def get_path_func(self, matrix):
        rotational_components = [
            sign*np.arccos(matrix[i,i]/get_norm(matrix[:,i]))
            for i in [0, 1]
            for sign in [((-1)**i)*np.sign(matrix[1-i, i])]
        ]
        average_rotation = sum(rotational_components)/2
        if abs(average_rotation) < np.pi / 2:
            return straight_path
        elif average_rotation > 0:
            return counterclockwise_path()
        else:
            return clockwise_path()


class Show90DegreeRotation(TransformScene2D):
    def construct(self):
        self.add_number_plane()
        self.add_background()
        self.add_x_y_arrows()

        self.wait()
        self.play(*[
            RotationAsTransform(mob, run_time = 2.0)
            for mob in (self.number_plane, self.x_arrow, self.y_arrow)
        ])
        self.wait()

