import sys
import math
from kivy.uix.widget import Widget
from kivy.core.window import Window

from point import Point
from polyomino import Square
from polyomino import Square_element

from tools import remove_fromlist

# painter class
class Painter(Widget):

    def __init__(self,app,**kwargs):

        # list of particles
        self.particles=[]

        # particle under mouse
        self.undermouse=None

        # list of selected particles
        self.selected=[]
        # complement
        self.unselected=self.particles

        # relative position of mouse when moving
        self.offset=Point(0,0)

        # app is used to share information between widgets
        self.app=app

        # modifiers
        self.modifiers=[]

        # init Widget
        super(Painter,self).__init__(**kwargs)

        # init keyboard
        self.keyboard = Window.request_keyboard(None,self,"text")
        self.keyboard.bind(on_key_down=self.on_key_down,on_key_up=self.on_key_up)

    
    def reset(self):
        self.particles=[]
        self.undermouse=None
        self.draw()


    # draw all particles
    def draw(self):
        self.canvas.clear()
        with self.canvas:
            for particle in self.particles:
                particle.draw()


    # respond to keyboard
    def on_key_down(self, keyboard, keycode, text, modifiers):
        # check that command_prompt is not focused
        if not self.app.command_prompt.insert:
            if keycode[1]=="shift":
                if not 's' in self.modifiers:
                    self.modifiers.append('s')
                    self.modifiers.sort()

    def on_key_up(self, keyboard, keycode):
        if keycode[1]=="shift":
            if 's' in self.modifiers:
                # remove
                self.modifiers[self.modifiers.index('s')]=self.modifiers[len(self.modifiers)-1]
                self.modifiers=self.modifiers[:len(self.modifiers)-1]
                self.modifiers.sort()


    # respond to mouse down
    def on_touch_down(self,touch):
        # only respond to touch in drawing area
        if self.collide_point(*touch.pos):

            # create new cross
            if touch.button=="right":
                new=Square(touch.x/Square_element.size,touch.y/Square_element.size)
                if not self.check_interaction_any(new,Point(0,0)):
                    # add to list
                    self.particles.append(new)

                    # unselect all particles
                    for sel in self.selected:
                        sel.selected=False
                    self.selected=[]
                    self.unselected=self.particles

                    self.draw()

            # select particle
            if touch.button=="left":
                # find particle under touch
                self.undermouse=self.find_particle(Point(touch.x/Square_element.size,touch.y/Square_element.size))

                # record relative position of click with respect to reference
                if self.undermouse!=None:
                    self.offset=Point(touch.x/Square_element.size,touch.y/Square_element.size)-self.undermouse.squares[0].pos

                # no modifiers
                if self.modifiers==[]:
                    if self.undermouse==None:
                        # unselect all particles
                        for sel in self.selected:
                            sel.selected=False
                        self.selected=[]
                        self.unselected=self.particles
                    # select undermouse
                    elif not self.undermouse in self.selected:
                        for sel in self.selected:
                            sel.selected=False
                        self.selected=[self.undermouse]
                        self.unselected=self.particles.copy()
                        self.unselected=remove_fromlist(self.unselected,self.undermouse)
                        self.undermouse.selected=True


                # shift-click
                elif self.modifiers==['s']:
                    if self.undermouse!=None:
                        if self.undermouse not in self.selected:
                            self.selected.append(self.undermouse)
                            self.undermouse.selected=True
                            # remove from unselected
                            self.unselected=remove_fromlist(self.unselected,self.undermouse)
                        else:
                            # remove
                            self.selected=remove_fromlist(self.selected,self.undermouse)
                            self.undermouse.selected=False
                            # add to unselected
                            self.unselected.append(self.undermouse)

                self.draw()


    # respond to drag
    def on_touch_move(self,touch):
        # only respond to touch in drawing area
        if self.collide_point(*touch.pos):
            # only move on left click
            if touch.button=="left" and self.modifiers==[] and self.undermouse!=None:
                # attempted move determined by the relative position to the relative position of click within self.undermouse
                delta=self.adjust_move(Point(touch.x/Square_element.size,touch.y/Square_element.size)-(self.offset+self.undermouse.squares[0].pos))
                for particle in self.selected:
                    particle.move(delta)

                # redraw
                self.draw()


    # find the particle at position pos
    def find_particle(self,pos):
        for particle in self.particles:
            if particle.in_support(pos):
                return particle
        # none found
        return None

    # check whether a candidate particle intersects with any of the particles
    def check_interaction_any(self,candidate,offset):
        for particle in self.particles:
            # do not check interaction if candidate=particle
            if candidate!=particle and particle.check_interaction(candidate,offset):
                return True
        return False

    # check whether shifting a list of particles by offset makes them interact with all particles
    def check_interaction_list(self,array,offset):
        for candidate in array:
            if self.check_interaction_any(candidate,offset):
                return True
        return False

    # check whether shifting a list of particles by offset makes them interact with the unselected particles
    def check_interaction_unselected_list(self,array,offset):
        for candidate in array:
            for particle in self.unselected:
                if particle.check_interaction(candidate,offset):
                    return True
        return False

    # check whether a candidate particle element with any of the unselected particles
    def check_interaction_unselected_element(self,element,offset):
        for particle in self.unselected:
            for square in particle.squares:
                if square.check_interaction(element.pos+offset):
                    return True
        return False


    # try to move all selected particles by delta, adjust if needed to avoid overlap with unselected particles
    # we only track whether these elements collide with unselected particles, not with each other
    def adjust_move(self,delta):
        # actual_delta is the smallest (componentwise) of all the computed delta's
        actual_delta=Point(math.inf,math.inf)
        for particle in self.selected:
            for element in particle.squares:
                # compute adjustment move due to unselected obstacles
                adjusted_delta=self.adjust_move_element(delta,element)
                # only keep the smallest delta's (in absolute value)
                if abs(adjusted_delta.x)<abs(actual_delta.x):
                    actual_delta.x=adjusted_delta.x
                if abs(adjusted_delta.y)<abs(actual_delta.y):
                    actual_delta.y=adjusted_delta.y
        # try to move by actual_delta
        if not self.check_interaction_unselected_list(self.selected,actual_delta):
            return actual_delta
        else:
            # cannot move particles at all, try again
            return self.adjust_move(actual_delta)


    # trying to move a single element by delta, adjust if needed to avoid overlap with unselected particles
    def adjust_move_element(self,delta,element):
        # whether newpos is acceptable
        accept_newpos=True
        for other in self.unselected:
            for obstacle in other.squares:
                # move would make element overlap with obstacle
                if obstacle.check_interaction(element.pos+delta):
                    accept_newpos=False
                    # check if particle already touches obstacle
                    if obstacle.check_touch(element.pos):
                        # move along obstacle while remaining stuck
                        newdelta=obstacle.move_along(delta,element.pos)
                    else:
                        newdelta=obstacle.move_on_line_to_stick(element.pos,delta)
                    if not self.check_interaction_unselected_element(element,newdelta):
                        return newdelta
        if accept_newpos:
            return delta
        else:
            # cannot move particle at all, try again
            return self.adjust_move_element(newdelta,element)


    # TODO adapt
    # write configuration to file
    def write(self,file):
        ff=open(file,"w")
        for particle in self.particles:
            ff.write("{:05.2f},{:05.2f};{:3.1f},{:3.1f},{:3.1f}\n".format(particle.pos.x,particle.pos.y,particle.color[0],particle.color[1],particle.color[2]))
        ff.close()

    # TODO adapt
    # read configuration from file
    def read(self,file):
        self.reset()
        try:
            ff=open(file,"r")
        except:
            self.app.command_prompt.message="error: could not read file '"+file+"' (this should not happen and is probably a bug)"
            return

        # counter
        i=0

        try:
            lines=ff.readlines()
        except:
            self.app.command_prompt.message="error: could not read the contents of file '"+file+"'"
            return

        for line in lines:
            i+=1

            # remove newline
            line=line[:len(line)-1]

            # ignore comments
            if '#' in line:
                line=line[:line.find('#')]
            # ignore empty lines
            if len(line)==0:
                continue

            entries=line.split(";")
            # skip line if improperly formatted
            if len(entries)>2:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': more than two ';' spearated entries in '"+line+"'",file=sys.stderr)
                continue

            # position
            pos_str=entries[0].split(",")
            # skip line if improperly formatted
            if len(pos_str)!=2:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': position '"+entries[0]+"' does not have two components",file=sys.stderr)
                continue
            try:
                pos=Point(float(pos_str[0]),float(pos_str[1]))
            except:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': position '"+entries[0]+"' cannot be read",file=sys.stderr)
                continue
                

            # color
            color=(0,0,1)
            if len(entries)==2:
                color_str=entries[1].split(",")
                # skip line if improperly formatted
                if len(color_str)!=3:
                    print("warning: ignoring line "+str(i)+" in file '"+file+"': color '"+entries[1]+"' does not have three components",file=sys.stderr)
                    continue
                try:
                    color=(float(color_str[0]),float(color_str[1]),float(color_str[2]))
                except:
                    print("warning: ignoring line "+str(i)+" in file '"+file+"': color '"+entries[1]+"' cannot be read",file=sys.stderr)
                    continue

            if self.check_interaction_any(pos,None):
                # add to list
                self.particles.append(Cross(pos.x,pos.y,color=color))
            else:
                print("warning: ignoring line "+str(i)+" in file '"+file+"': particle overlaps with existing particles",file=sys.stderr)
            
        ff.close()
        self.draw()