from __future__ import print_function
import numpy as np

class CoordPair(object):
   def __init__(self, fst, snd=None):
      if snd == None: fst, snd = fst
      self.fst, self.snd = fst,snd

   @property
   def pair(self):
      return self.fst, self.snd

   def __len__(self): return 2
   def __iter__(self): return iter(self.pair)
   def __getitem__(self, idx):
      if idx == 0: return self.fst
      elif idx == 1: return self.snd
      else: raise KeyError("Only two elements in a coordpair")

   def transform(self, *transforms):
      '''Note: mul _then_ add'''
      f,s = self.pair
      for transform in transforms:
         x = transform.get('mul', (1,1))
         if not hasattr(x, '__iter__'): x=(x,x)
         f1,f2 = x
         f *= f1
         s *= f2
         x = transform.get('add', (0,0))
         if not hasattr(x, '__iter__'): x=(x,x)
         f1,f2 = x
         f += f1
         s += f2
      return f,s

   def __ne__(self, other):
      return not self.__eq__(other)
   def __rne__(self, other):
      return not self.__eq__(other)

   def __eq__(self, other):
      a,b = self
      c,d = other
      return a==c and b==d
   def __req__(self, other):
      return self == other

   def __add__(self, other):
      return self.__class__(self.transform({'add': other}))
   def __radd__(self, other):
      return self.__class__(self.transform({'add': other}))

   def __mul__(self, other):
      return self.__class__(self.transform({'mul': other}))
   def __rmul__(self, other):
      return self.__class__(self.transform({'mul': other}))


   def __sub__(self, other):
      a,b = other
      return self.__class__(self.transform({'add': (-a,-b)}))
   def __rsub__(self, other):
      a,b = other
      return self.__class__(self.transform({'add': (-a,-b)}))

   def __div__(self, other):
      return self.__class__(self.transform({'mul': 1.0/other}))
   def __rdiv__(self, other):
      return self.__class__(self.transform({'mul': 1.0/other}))

   def __repr__(self):
      return '%s(%s,%s)' % (self.__class__.__name__, self.fst, self.snd)

class MazeDigger(object):
   def __init__(self, traveller, size, multiplier=3):
      self.t = traveller
      self.size = CoordPair(*size)*multiplier
      self.mult = multiplier
      self.map = np.ones(self.size+1, int)*2

   def clamp(self, start):
      if start.fst < 0: start.fst = 0
      elif start.fst >= self.size.fst: start.fst = self.size.fst-1
      if start.snd < 0: start.snd = 0
      elif start.snd >= self.size.snd: start.snd = self.size.snd-1
      return start

   def draw_line(self, fro, to):
      (x1,y1),  (x2,y2) = fro, to
      if x2<x1: x1,x2 = x2,x1
      if y2<y1: y1,y2 = y2,y1
      x1*=self.mult;x2*=self.mult
      x2 += 1
      y1*=self.mult;y2*=self.mult
      y2 += 1
      self.map[x1+1:x2+1,y1+1:y2+1] = 3

   def make_map(self):
      for x,y in self.t.visited:
         self.map[x*self.mult:(x+1)*self.mult, y*self.mult:(y+1)*self.mult] = 0
      for fro, to in self.t.connections:
         self.draw_line(fro, to)
      x,y = self.t.pos
      #self.map[x*self.mult:(x+1)*self.mult, y*self.mult:(y+1)*self.mult] = 1
      return self

   def show_map(self):
      nmap = np.rollaxis(self.map, 1)
      for row in nmap:
         for col in row:
            if col == 3: print('.', end='')
            if col == 2: print('#', end='')
            if col == 1: print('o', end='')
            if col == 0: print('x', end='')
         print()

   def tcod_show_map(self):
      nmap = self.map.copy()
      nmap = nmap.max() - nmap
      omin = nmap.min()
      nmap -= omin
      omax = nmap.max()
      nmap *= 255
      nmap /= omax
      nmap = np.rollaxis(nmap, 1)
      tc.console_fill_background(0, nmap,nmap,nmap)


if __name__ == '__main__':
   import sys
   aldus = __import__(sys.argv[1])
   import time
   import libtcodpy as tc

   self = MazeDigger(aldus.t, (aldus.x,aldus.y))

   tc.console_init_root(self.size.fst+1, self.size.snd+1, 'The Title', False, 2)
   tc.sys_set_fps(30)

   key, mouse = tc.Key(), tc.Mouse()

   walk_result = False
   while True:
      tc.sys_check_for_event(tc.EVENT_KEY_PRESS|tc.EVENT_MOUSE|tc.KEY_PRESSED, key, mouse)
      if key.c == ord('q'): break

      if not walk_result:
         walk_result = aldus.t.random_walk(aldus.maze)
         self.make_map()

         tc.sys_save_screenshot('tmp.png')
         self.tcod_show_map()

      tc.console_flush()