try:
    import json
except:
    import simplejson as json

import os

from . import data
from . import options
from .sprites.base import find_sprite


class StateProxy(object):

    def __init__(self, data, gamestate):
        self.__dict__['_data'] = data # should be a dict
        self.__dict__['_gamestate'] = gamestate # use sparingly

    def __getattr__(self, key):
        try:
            value = self._data[key]
        except KeyError:
            raise AttributeError
        if isinstance(value, dict):
            return StateProxy(value, None) # surprise people
        else:
            return value

    def __setattr__(self, key, value):
        self._data[key] = value

    def __iter__(self):
        return self._data.iterkeys()

    def __contains__(self, key):
        return key in self._data

    def copy(self):
        return self._data.copy()

    def gamestate(self):
        return self._gamestate


class GameState(object):

    def __init__(self, game_file):
        self._game_file = game_file
        self.world = None

    def can_resume(self):
        return os.path.exists(self._game_file)

    def load_game(self, game_file=None):
        if game_file is None:
            game_file = self._game_file
        raw_data = open(game_file, "rb").read()
        self.data = json.loads(raw_data, encoding='utf-8')
        self.world = StateProxy(self.data, self)

    def new_game(self):
        self.load_game(data.filepath("game.json"))
        if options['all_tails']:
            self.data['fox']['tails'] += [
                "fireball",
                "flight",
                "invisibility",
                "lightning",
                "shapeshift",
                "shield",
                "sprint",
                "steal",
            ]
        self.save_game()

    def save_game(self):
        if self.world is None:
            return
        save_dir, _ = os.path.split(self._game_file)
        if not os.path.exists(save_dir):
            try:
                os.makedirs(save_dir)
            except:
                print "Cannot create save game directory."
                return
        try:
            json.dump(self.data, open(self._game_file, "wb"), indent=4)
        except:
            print "Cannot create save game file."

    def create_sprites(self, level):
        sprites = []
        for stype, key in [
            ('items', 'items'),
            ('npcs', 'npcs')]:
            for sprite_name, sprite_dict in self.data[key].items():
                sprite_dict = sprite_dict.copy()
                sprite_dict['name'] = sprite_name
                sprite_dict['world'] = self.world
                if sprite_dict.pop('level') == level:
                    sprites.append(find_sprite(sprite_dict, stype))
        return sprites

    def create_item_sprite(self, item, to_level=None, to_pos=None):
        itemdef = self.data['items'][item]

        if to_level is not None:
            itemdef['level'] = to_level
        if to_pos is not None:
            itemdef['pos'] = to_pos

        sprite_dict = itemdef.copy()
        sprite_dict.pop('level')
        sprite_dict['name'] = item
        sprite_dict['world'] = self.world
        return find_sprite(sprite_dict, 'items')

    def create_npc_sprite(self, npc, to_level=None, to_pos=None):
        npcdef = self.data['npcs'][npc]

        if to_level is not None:
            npcdef['level'] = to_level
        if to_pos is not None:
            npcdef['pos'] = to_pos

        sprite_dict = npcdef.copy()
        sprite_dict.pop('level')
        sprite_dict['name'] = npc
        sprite_dict['world'] = self.world
        return find_sprite(sprite_dict, 'npcs')