import { DIRECTIONS } from './defs.js';

const TILE_TYPES = {
    // Floors and walls
    floor: {
    },
    floor_letter: {
        load(me, template) {
            me.ascii_code = template.modifier;
        },
    },
    wall: {
        blocks: true,
    },
    wall_invisible: {
        // TODO cc2 seems to make these flicker briefly
        blocks: true,
    },
    wall_appearing: {
        blocks: true,
        on_bump(me, level, other) {
            me.become('wall');
        },
    },
    popwall: {
        on_depart(me, level, other) {
            me.become('wall');
        },
    },
    thinwall_n: {
        thin_walls: new Set(['north']),
    },
    thinwall_s: {
        thin_walls: new Set(['south']),
    },
    thinwall_e: {
        thin_walls: new Set(['east']),
    },
    thinwall_w: {
        thin_walls: new Set(['west']),
    },
    thinwall_se: {
        thin_walls: new Set(['south', 'east']),
    },
    fake_wall: {
        blocks: true,
        on_bump(me, level, other) {
            me.become('wall');
        },
    },
    fake_floor: {
        blocks: true,
        on_bump(me, level, other) {
            me.become('floor');
        },
    },

    // Swivel doors
    swivel_floor: {},
    swivel_ne: {
        thin_walls: new Set(['north', 'east']),
    },
    swivel_se: {
        thin_walls: new Set(['south', 'east']),
    },
    swivel_sw: {
        thin_walls: new Set(['south', 'west']),
    },
    swivel_nw: {
        thin_walls: new Set(['north', 'west']),
    },

    // Locked doors
    door_red: {
        blocks: true,
        on_bump(me, level, other) {
            if (other.type.has_inventory && other.take_item('key_red')) {
                me.type = TILE_TYPES.floor;
            }
        },
    },
    door_blue: {
        blocks: true,
        on_bump(me, level, other) {
            if (other.type.has_inventory && other.take_item('key_blue')) {
                me.type = TILE_TYPES.floor;
            }
        },
    },
    door_yellow: {
        blocks: true,
        on_bump(me, level, other) {
            if (other.type.has_inventory && other.take_item('key_yellow')) {
                me.type = TILE_TYPES.floor;
            }
        },
    },
    door_green: {
        blocks: true,
        on_bump(me, level, other) {
            if (other.type.has_inventory && other.take_item('key_green')) {
                me.type = TILE_TYPES.floor;
            }
        },
    },

    // Terrain
    dirt: {
        blocks_monsters: true,
        blocks_blocks: true,
        // TODO block melinda only without the hiking boots; can't use ignore because then she wouldn't step on it  :S  also ignore doesn't apply to blocks anyway.
        on_arrive(me, level, other) {
            me.become('floor');
        },
    },
    gravel: {
        blocks_monsters: true,
    },

    // Hazards
    fire: {
        on_arrive(me, level, other) {
            if (other.type.is_player) {
                level.fail("Oops!  You can't walk on fire without fire boots!");
                other.become('player_burned');
            }
            else {
                other.destroy();
            }
        },
    },
    water: {
        on_arrive(me, level, other) {
            // TODO cc1 allows items under water, i think; water was on the upper layer
            if (other.type.name == 'dirt_block' || other.type.name == 'clone_block') {
                other.destroy();
                me.become('dirt');
            }
            else if (other.type.is_player) {
                level.fail("Oops!  You can't swim without flippers!");
                other.become('player_drowned');
            }
            else {
                other.destroy();
            }
        },
    },
    turtle: {
    },
    ice: {
        on_arrive(me, level, other) {
            level.make_slide(other, 'ice');
        },
    },
    ice_sw: {
        thin_walls: new Set(['south', 'west']),
        on_arrive(me, level, other) {
            if (other.direction === 'south') {
                other.direction = 'east';
            }
            else {
                other.direction = 'north';
            }
            level.make_slide(other, 'ice');
        },
    },
    ice_nw: {
        thin_walls: new Set(['north', 'west']),
        on_arrive(me, level, other) {
            if (other.direction === 'north') {
                other.direction = 'east';
            }
            else {
                other.direction = 'south';
            }
            level.make_slide(other, 'ice');
        },
    },
    ice_ne: {
        thin_walls: new Set(['north', 'east']),
        on_arrive(me, level, other) {
            if (other.direction === 'north') {
                other.direction = 'west';
            }
            else {
                other.direction = 'south';
            }
            level.make_slide(other, 'ice');
        },
    },
    ice_se: {
        thin_walls: new Set(['south', 'east']),
        on_arrive(me, level, other) {
            if (other.direction === 'south') {
                other.direction = 'west';
            }
            else {
                other.direction = 'north';
            }
            level.make_slide(other, 'ice');
        },
    },
    force_floor_n: {
        on_arrive(me, level, other) {
            other.direction = 'north';
            level.make_slide(other, 'force');
        },
    },
    force_floor_e: {
        on_arrive(me, level, other) {
            other.direction = 'east';
            level.make_slide(other, 'force');
        },
    },
    force_floor_s: {
        on_arrive(me, level, other) {
            other.direction = 'south';
            level.make_slide(other, 'force');
        },
    },
    force_floor_w: {
        on_arrive(me, level, other) {
            other.direction = 'west';
            level.make_slide(other, 'force');
        },
    },
    force_floor_all: {
        // TODO cc2 cycles these...
    },
    bomb: {
        // TODO explode
        on_arrive(me, level, other) {
            me.destroy();
            other.destroy();
        },
    },
    thief_tools: {
        on_arrive(me, level, other) {
            if (other.inventory) {
                for (let [name, count] of Object.entries(other.inventory)) {
                    if (count > 0 && TILE_TYPES[name].is_tool) {
                        other.take_item(name, count);
                    }
                }
            }
        },
    },
    thief_keys: {
        on_arrive(me, level, other) {
            if (other.inventory) {
                for (let [name, count] of Object.entries(other.inventory)) {
                    if (count > 0 && TILE_TYPES[name].is_key) {
                        other.take_item(name, count);
                    }
                }
            }
        },
    },
    forbidden: {
    },

    // Mechanisms
    dirt_block: {
        blocks: true,
        is_object: true,
        is_block: true,
        ignores: new Set(['fire']),
    },
    clone_block: {
        // TODO is this in any way distinct from dirt block
        blocks: true,
        is_object: true,
        is_block: true,
        ignores: new Set(['fire']),
    },
    green_floor: {},
    green_wall: {
        blocks: true,
    },
    cloner: {
        blocks: true,
        activate(me, level) {
            let cell = level.cells[me.y][me.x];
            // Clone so we don't end up repeatedly cloning the same object
            let current_tiles = Array.from(cell);
            for (let tile of current_tiles) {
                if (tile !== me && tile.type.is_actor) {
                    tile.stuck = false;
                    // TODO precise behavior?  is this added immediately and can move later that same turn or what?
                    level.actors.push(tile);
                    // FIXME rearrange to make this possible lol
                    // FIXME go through level for this, and everything else of course
                    // FIXME add this underneath, just above the cloner
                    cell._add(new tile.constructor(tile.type, tile.x, tile.y, tile.direction));
                }
            }
        },
    },
    trap: {
        on_arrive(me, level, other) {
            if (! me.open) {
                other.stuck = true;
            }
        },
    },
    teleport_blue: {
        // TODO
    },
    // Buttons
    button_blue: {
        on_arrive(me, level, other) {
            // Flip direction of all tanks
            for (let actor of level.actors) {
                // TODO generify somehow??
                if (actor.type.name === 'tank_blue') {
                    actor.direction = DIRECTIONS[actor.direction].opposite;
                }
            }
        },
    },
    button_green: {
        on_arrive(me, level, other) {
            // Swap green floors and walls
            for (let row of level.cells) {
                for (let cell of row) {
                    for (let tile of cell) {
                        if (tile.type.name === 'green_floor') {
                            tile.become('green_wall');
                        }
                        else if (tile.type.name === 'green_wall') {
                            tile.become('green_floor');
                        }
                        else if (tile.type.name === 'green_chip') {
                            tile.become('green_bomb');
                        }
                        else if (tile.type.name === 'green_bomb') {
                            tile.become('green_chip');
                        }
                    }
                }
            }
        },
    },
    button_brown: {
        connects_to: 'trap',
        connect_order: 'forward',
        on_arrive(me, level, other) {
            if (me.connection && ! me.connection.doomed) {
                // TODO do gray buttons affect traps?  if so this should use activate()
                let trap = me.connection;
                trap.open = true;
                for (let tile of level.cells[trap.y][trap.x]) {
                    if (tile.stuck) {
                        tile.stuck = false;
                    }
                }
            }
        },
        on_depart(me, level, other) {
            if (me.connection && ! me.connection.doomed) {
                // TODO do gray buttons affect traps?  if so this should use activate()
                let trap = me.connection;
                trap.open = false;
                for (let tile of level.cells[trap.y][trap.x]) {
                    if (tile.is_actor) {
                        tile.stuck = false;
                    }
                }
            }
        },
    },
    button_red: {
        connects_to: 'cloner',
        connect_order: 'forward',
        on_arrive(me, level, other) {
            if (me.connection && ! me.connection.doomed) {
                me.connection.type.activate(me.connection, level);
            }
        },
    },

    // Critters
    bug: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_mode: 'follow-left',
        movement_speed: 4,
    },
    paramecium: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_mode: 'follow-right',
        movement_speed: 4,
    },
    ball: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_mode: 'bounce',
        movement_speed: 4,
    },
    walker: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        // TODO movement_move: 'bounce-random',
        movement_speed: 4,
    },
    tank_blue: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_mode: 'forward',
        movement_speed: 4,
    },
    blob: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_speed: 8,
    },
    teeth: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_speed: 4,
    },
    fireball: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_mode: 'turn-right',
        movement_speed: 4,
        ignores: new Set(['fire']),
    },
    glider: {
        is_actor: true,
        is_object: true,
        is_monster: true,
        blocks_monsters: true,
        movement_mode: 'turn-left',
        movement_speed: 4,
        ignores: new Set(['water']),
    },

    // Keys
    key_red: {
        is_object: true,
        is_item: true,
        is_key: true,
    },
    key_blue: {
        is_object: true,
        is_item: true,
        is_key: true,
    },
    key_yellow: {
        is_object: true,
        is_item: true,
        is_key: true,
    },
    key_green: {
        is_object: true,
        is_item: true,
        is_key: true,
    },
    // Tools
    cleats: {
        is_object: true,
        is_item: true,
        is_tool: true,
        item_ignores: new Set(['ice', 'ice_nw', 'ice_ne', 'ice_sw', 'ice_se']),
    },
    suction_boots: {
        is_object: true,
        is_item: true,
        is_tool: true,
        item_ignores: new Set([
            'force_floor_n',
            'force_floor_s',
            'force_floor_e',
            'force_floor_w',
        ]),
    },
    fire_boots: {
        is_object: true,
        is_item: true,
        is_tool: true,
        item_ignores: new Set(['fire']),
    },
    flippers: {
        is_object: true,
        is_item: true,
        is_tool: true,
        item_ignores: new Set(['water']),
    },

    // Progression
    player: {
        is_actor: true,
        is_player: true,
        has_inventory: true,
        is_object: true,
        movement_speed: 4,
        pushes: {
            dirt_block: true,
            clone_block: true,
        },
        // FIXME this prevents thief from taking green key
        infinite_items: {
            key_green: true,
        },
    },
    player_drowned: {
    },
    player_burned: {
    },
    chip: {
        is_object: true,
        is_chip: true,
        is_required_chip: true,
        blocks_monsters: true,
        blocks_blocks: true,
        on_arrive(me, level, other) {
            if (other.type.is_player) {
                level.collect_chip();
                me.destroy();
            }
        },
    },
    chip_extra: {
        is_chip: true,
        is_object: true,
    },
    score_10: {
        is_object: true,
    },
    score_100: {
        is_object: true,
    },
    score_1000: {
        is_object: true,
    },
    score_2x: {
        is_object: true,
    },

    hint: {
        is_hint: true,
    },
    socket: {
        blocks: true,
        on_bump(me, level, other) {
            if (other.type.is_player && level.chips_remaining === 0) {
                me.type = TILE_TYPES.floor;
            }
        },
    },
    exit: {
        on_arrive(me, level, other) {
            if (other.type.is_player) {
                level.win();
            }
        },
    },
};

// Tell them all their own names
for (let [name, type] of Object.entries(TILE_TYPES)) {
    type.name = name;
}

export default TILE_TYPES;