#!/usr/bin/python

import random, os, time

WALL_CHAR = '#'
FLOOR_CHAR = '.'
PLAYER_CHAR = '@'
EXIT_CHAR = 'X'
COIN_CHAR = '*'
ENEMY_CHAR = 'a'
WATER_CHAR = '~'

def random_fill():
    if random.randint(0, 100) < 28:
        return WALL_CHAR
    else:
        return FLOOR_CHAR

def count_walls_around(arr, i, j, n):
    counter = 0
    diff = [-n+i for i in range(2*n+1)]
    for k in diff:
        for m in diff:
#            if k==0 and m ==0:
#               continue
            try:
                if arr[i+k][j+m] == WALL_CHAR:
                    counter += 1
            except IndexError:
                continue
    return counter

def dist(x1, y1, x2, y2):
    return abs(x2-x1)+abs(y2-y1)

def return_max_region(regions):
    if len(regions)==1:
        return regions[0]
    else:
        lens = [len(i) for i in regions]
        maxlen = max(lens)
        return regions[lens.index(maxlen)]

class Dungeon:
    def __init__(self, n, m):
        self.height, self.width = n, m
        self.marray = [[WALL_CHAR]*self.width for _ in range(self.height)]
        self.update()

    def update(self):
        self.sarray = [''.join(i) for i in self.marray]

    def make_borders(self):
        for i in range(1, self.height-1):
            for j in range(1, self.width-1):
                self.marray[i][j] = FLOOR_CHAR
        self.update()

    def iterate_CA(self):
        for i in range(1, self.height-1):
            for j in range(1, self.width-1):
                c1 = count_walls_around(self.marray, i, j, 1)
                c2 = count_walls_around(self.marray, i, j, 2)
                if c1 > 4 or c2 < 3:
                    self.marray[i][j] = WALL_CHAR


    def iterate_CA_s(self):
        for i in range(1, self.height-1):
            for j in range(1, self.width-1):
                c1 = count_walls_around(self.marray, i, j, 1)
                if c1 < 3:
                    self.marray[i][j] = FLOOR_CHAR

    def make_CA(self):
        #random initialisation
        for i in range(1, self.height-1):
            for j in range(1, self.width-1):
                self.marray[i][j] = random_fill()
#        self.make_borders()
        self.update()
        self.show_dungeon()
        for i in range(5):
            self.iterate_CA()
            self.update()
            self.show_dungeon()
        for i in range(5):
           self.iterate_CA_s()
           self.update
           self.show_dungeon()

    def floor_coords(self):
        self.floor = []
        for i in range(1, self.height-1):
            for j in range(1, self.width-1):
                if self.marray[i][j] not in (WALL_CHAR, WATER_CHAR):
                    self.floor.append((i, j))

    def set_player_exit(self):
        x, y = self.max_region[0]
        self.marray[x][y] = PLAYER_CHAR
        x, y = self.max_region[-1]
        self.marray[x][y] = EXIT_CHAR
        self.update()
        self.show_dungeon()

    def set_coin(self):
        u_floor = self.max_region[1:-1]
        for i,j in u_floor:
            r = random.randint(0,100)
            if r < 20:
                self.marray[i][j] = COIN_CHAR
        self.update()
        self.show_dungeon()

    def set_enemy(self):
        x1, y1 = self.max_region[-1]
        if 300 < len(self.max_region):
            for i, j in self.max_region:
                if dist(i, j, x1, y1) == 7:
                    self.marray[i][j] = ENEMY_CHAR
                    break
        if len(self.max_region) > 400:
             x1, y1 = self.max_region[0]
             for i, j in self.max_region:
                if dist(i, j, x1, y1) == 11:
                    self.marray[i][j] = ENEMY_CHAR
                    break
        self.update()
        self.show_dungeon()

    def show_dungeon(self):
        time.sleep(0.05)
       #os.system('clear')
        for i in self.sarray:
            print(i)

    def is_water_nearby(self, i, j):
        if self.marray[i][j-1] == WATER_CHAR or self.marray[i][j+1] == WATER_CHAR or self.marray[i-1][j] == WATER_CHAR or self.marray[i+1][j] == WATER_CHAR:
            return True

    def iterate_water(self):
        for i, j in self.floor:
            if self.is_water_nearby(i, j):
                self.marray[i][j] = WATER_CHAR
        self.floor_coords()
        self.update()
        self.show_dungeon()

    def count_water(self):
        counter = 0
        for i in range(self.height):
            for j in range(self.width):
                if self.marray[i][j] == WATER_CHAR:
                    counter += 1
        return counter


    def set_regions(self):
        regions = []
        used_cells = []
        while self.floor:
            i, j = self.floor[0]
            self.marray[i][j] = WATER_CHAR
            counter = 1
            done = False
            while not done:
                self.iterate_water()
                new_counter = self.count_water()
                if counter == new_counter:
                    done = True
                else:
                    counter = new_counter
            region = []
            for i in range(self.height):
                for j in range(self.width):
                    if self.marray[i][j] == WATER_CHAR and (i,j) not in used_cells:
                        region.append((i,j))
            regions.append(region.copy())
            used_cells = [item for sublist in regions for item in sublist]
        self.max_region = return_max_region(regions)
        for i in range(self.height):
            for j in range(self.width):
                if self.marray[i][j] == WATER_CHAR:
                    self.marray[i][j] = FLOOR_CHAR
        self.update()
        self.show_dungeon()
        self.max_region = return_max_region(regions)
        print(self.max_region)

n, m = 30, 90
dungeon = Dungeon(n, m)
filename = 'init.txt'
dungeon.make_CA()
dungeon.floor_coords()
dungeon.set_regions()
dungeon.set_player_exit()
dungeon.set_coin()
dungeon.set_enemy()

with open(filename, 'w') as f:
    for i in dungeon.sarray:
        f.write(i+'\n')