from ctypes import *
from flags import *
from enum import *
import util
from util import *

libdfhack = cdll.libdfhack

def _register_callback(name, func):
    ptr = c_void_p.in_dll(libdfhack, name)
    ptr.value = cast(func, c_void_p).value

_register_callback("alloc_byte_buffer_callback", alloc_byte_buffer)
_register_callback("alloc_ubyte_buffer_callback", alloc_ubyte_buffer)
_register_callback("alloc_short_buffer_callback", alloc_short_buffer)
_register_callback("alloc_ushort_buffer_callback", alloc_ushort_buffer)
_register_callback("alloc_int_buffer_callback", alloc_int_buffer)
_register_callback("alloc_uint_buffer_callback", alloc_uint_buffer)
_register_callback("alloc_char_buffer_callback", alloc_char_buffer)

_arr_create_func = CFUNCTYPE(c_void_p, c_int)
_dfhack_string = (c_char * 128)

TileTypes40d = ((c_int * 16) * 16)
BiomeIndices40d = c_ubyte * 16
Temperatures = ((c_ushort * 16) * 16)
Designations40d = ((DesignationFlags * 16) * 16)
Occupancies40d = ((OccupancyFlags * 16) * 16)

def wall_terrain_check(terrain):
    return libdfhack.DFHack_isWallTerrain(terrain) > 0

def floor_terrain_check(terrain):
    return libdfhack.DFHack_isFloorTerrain(terrain) > 0

def ramp_terrain_check(terrain):
    return libdfhack.DFHack_isRampTerrain(terrain) > 0

def stair_terrain_check(terrain):
    return libdfhack.DFHack_isStairTerrain(terrain) > 0

def open_terrain_check(terrain):
    return libdfhack.DFHack_isOpenTerrain(terrain) > 0

def get_vegetation_type(terrain):
    return libdfhack.DFHack_getVegetationType(terrain)

class Position2D(Structure):
    _fields_ = [("x", c_ushort),
                ("y", c_ushort)]

class Position3D(Structure):
    _fields_ = [("x", c_ushort),
                ("y", c_ushort),
                ("z", c_uint)]

class PlaneCoord(Union):
    _fields_ = [("xyz", Position3D),
                ("dim", Position2D),
                ("comparate", c_ulong)]

    def __cmp__(self, other):
        if isinstance(other, PlaneCoord):
            return self.comparate - other.comparate
        else:
            raise TypeError("argument must be of type %s" % type(self))

class Feature(Structure):
    _fields_ = [("type", FeatureType),
                ("main_material", c_short),
                ("sub_material", c_short),
                ("discovered", c_byte),
                ("origin", c_uint)]

class FeatureMapNode(Structure):
    _fields_ = [("coordinate", PlaneCoord),
                ("features", POINTER(Feature)),
                ("feature_length", c_uint)]

def _alloc_featuremap_buffer_callback(ptr, fmap_list, count):
    arr_list = []
    arr = (FeatureMapNode * count)()
    
    for i, v in enumerate(arr):
        f_count = int(fmap_list[i])
        f_arr = (Feature * f_count)()
        
        f_p = cast(f_arr, POINTER(Feature))
        v.features = f_p
        
        arr_list.extend((f_arr, f_p))
    
    p = cast(arr, POINTER(FeatureMapNode))
    ptr[0] = p
    
    pointer_dict[addressof(arr)] = (ptr, arr, p, arr_list)
    
    return 1

_alloc_featuremap_buffer_functype = CFUNCTYPE(c_int, POINTER(POINTER(FeatureMapNode)), uint_ptr, c_uint)
_alloc_featuremap_buffer_func = _alloc_featuremap_buffer_functype(_alloc_featuremap_buffer_callback)
_register_callback("alloc_featuremap_buffer_callback", _alloc_featuremap_buffer_func)

class Vein(Structure):
    _fields_ = [("vtable", c_uint),
                ("type", c_int),
                ("assignment", c_short * 16),
                ("flags", c_uint),
                ("address_of", c_uint)]

_vein_ptr = POINTER(Vein)

def _alloc_vein_buffer_callback(ptr, count):
    return util._allocate_array(ptr, Vein, count)

_vein_functype = CFUNCTYPE(c_int, POINTER(_vein_ptr), c_uint)
_vein_func = _vein_functype(_alloc_vein_buffer_callback)
_register_callback("alloc_vein_buffer_callback", _vein_func)

class FrozenLiquidVein(Structure):
    _fields_ = [("vtable", c_uint),
                ("tiles", TileTypes40d),
                ("address_of", c_uint)]

_frozenvein_ptr = POINTER(FrozenLiquidVein)

def _alloc_frozenliquidvein_buffer_callback(ptr, count):
    return util._allocate_array(ptr, FrozenLiquidVein, count)

_frozenliquidvein_functype = CFUNCTYPE(c_int, POINTER(_frozenvein_ptr), c_uint)
_frozenliquidvein_func = _frozenliquidvein_functype(_alloc_frozenliquidvein_buffer_callback)
_register_callback("alloc_frozenliquidvein_buffer_callback", _frozenliquidvein_func)

class SpatterVein(Structure):
    _fields_ = [("vtable", c_uint),
                ("mat1", c_ushort),
                ("unk1", c_ushort),
                ("mat2", c_uint),
                ("mat3", c_ushort),
                ("intensity", ((c_ubyte * 16) * 16)),
                ("address_of", c_uint)]

_spattervein_ptr = POINTER(SpatterVein)

def _alloc_spattervein_buffer_callback(ptr, count):
    return util._allocate_array(ptr, SpatterVein, count)

_spattervein_functype = CFUNCTYPE(c_int, POINTER(_spattervein_ptr), c_uint)
_spattervein_func = _spattervein_functype(_alloc_spattervein_buffer_callback)
_register_callback("alloc_spattervein_buffer_callback", _spattervein_func)

class GrassVein(Structure):
    _fields_ = [("vtable", c_uint),
                ("material", c_uint),
                ("intensity", ((c_ubyte * 16) * 16)),
                ("address_of", c_uint)]

_grassvein_ptr = POINTER(GrassVein)

def _alloc_grassvein_buffer_callback(ptr, count):
    return util._allocate_array(ptr, GrassVein, count)

_grassvein_functype = CFUNCTYPE(c_int, POINTER(_grassvein_ptr), c_uint)
_grassvein_func = _grassvein_functype(_alloc_grassvein_buffer_callback)
_register_callback("alloc_grassvein_buffer_callback", _grassvein_func)

class WorldConstruction(Structure):
    _fields_ = [("vtable", c_uint),
                ("material", c_uint),
                ("assignment", c_ushort * 16),
                ("address_of", c_uint)]

_worldconstruction_ptr = POINTER(WorldConstruction)

def _alloc_worldconstruction_buffer_callback(ptr, count):
    return util._allocate_array(ptr, WorldConstruction, count)

_worldconstruction_functype = CFUNCTYPE(c_int, POINTER(_worldconstruction_ptr), c_uint)
_worldconstruction_func = _worldconstruction_functype(_alloc_worldconstruction_buffer_callback)
_register_callback("alloc_worldconstruction_buffer_callback", _worldconstruction_func)

class MapBlock40d(Structure):
    _fields_ = [("tiletypes", TileTypes40d),
                ("designation", Designations40d),
                ("occupancy", Occupancies40d),
                ("biome_indices", BiomeIndices40d),
                ("origin", c_uint),
                ("blockflags", BlockFlags),
                ("global_feature", c_short),
                ("local_feature", c_short)]
                

class ViewScreen(Structure):
    _fields_ = [("type", c_int)]

class Matgloss(Structure):
    _fields_ = [("id", _dfhack_string),
                ("fore", c_byte),
                ("back", c_byte),
                ("bright", c_byte),
                ("name", _dfhack_string)]

_matgloss_ptr = POINTER(Matgloss)

def _alloc_matgloss_buffer_callback(ptr, count):
    return util._allocate_array(ptr, Matgloss, count)

_matgloss_functype = CFUNCTYPE(c_int, POINTER(_matgloss_ptr), c_uint)
_matgloss_func = _matgloss_functype(_alloc_matgloss_buffer_callback)
_register_callback("alloc_matgloss_buffer_callback", _matgloss_func)

class MatglossPair(Structure):
    _fields_ = [("type", c_short),
                ("index", c_int)]

class DescriptorColor(Structure):
    _fields_ = [("id", _dfhack_string),
                ("r", c_float),
                ("v", c_float),
                ("b", c_float),
                ("name", _dfhack_string)]

def _alloc_descriptor_buffer_callback(ptr, count):
    return util._allocate_array(ptr, DescriptorColor, count)

_descriptor_functype = CFUNCTYPE(c_int, POINTER(POINTER(DescriptorColor)), c_uint)
_descriptor_func = _descriptor_functype(_alloc_descriptor_buffer_callback)
_register_callback("alloc_descriptor_buffer_callback", _descriptor_func)

class MatglossPlant(Structure):
    _fields_ = [("id", _dfhack_string),
                ("fore", c_ubyte),
                ("back", c_ubyte),
                ("bright", c_ubyte),
                ("name", _dfhack_string),
                ("drink_name", _dfhack_string),
                ("food_name", _dfhack_string),
                ("extract_name", _dfhack_string)]

class MatglossOther(Structure):
    _fields_ = [("rawname", c_char * 128)]

def _alloc_matgloss_other_buffer_callback(ptr, count):
    return util._allocate_array(ptr, MatglossOther, count)

_matgloss_other_functype = CFUNCTYPE(c_int, POINTER(POINTER(MatglossOther)), c_uint)
_matgloss_other_func = _matgloss_other_functype(_alloc_matgloss_other_buffer_callback)
_register_callback("alloc_matgloss_other_buffer_callback", _matgloss_other_func)

class Building(Structure):
    _fields_ = [("origin", c_uint),
                ("vtable", c_uint),
                ("x1", c_uint),
                ("y1", c_uint),
                ("x2", c_uint),
                ("y2", c_uint),
                ("z", c_uint),
                ("material", MatglossPair),
                ("type", c_uint)]

class CustomWorkshop(Structure):
    _fields_ = [("index", c_uint),
                ("name", c_char * 256)]

def _alloc_custom_workshop_buffer_callback(ptr, count):
    return util._allocate_array(ptr, CustomWorkshop, count)

_custom_workshop_functype = CFUNCTYPE(c_int, POINTER(POINTER(CustomWorkshop)), c_uint)
_custom_workshop_func = _custom_workshop_functype(_alloc_custom_workshop_buffer_callback)
_register_callback("alloc_customWorkshop_buffer_callback", _custom_workshop_func)

class Construction(Structure):
    _fields_ = [("x", c_ushort),
                ("y", c_ushort),
                ("z", c_ushort),
                ("form", c_ushort),
                ("unk_8", c_ushort),
                ("mat_type", c_ushort),
                ("mat_idx", c_uint),
                ("unk3", c_ushort),
                ("unk4", c_ushort),
                ("unk5", c_ushort),
                ("unk6", c_uint),
                ("origin", c_uint)]

class Tree(Structure):
    _fields_ = [("type", c_ushort),
                ("material", c_ushort),
                ("x", c_ushort),
                ("y", c_ushort),
                ("z", c_ushort),
                ("address", c_uint)]
    
    def __str__(self):
        water = ""
        tree_type = "tree"
        
        if self.type == 1 or self.type == 3:
            water = "near-water"
        if self.type == 2 or self.type == 3:
            tree_type = "shrub"
        
        s = "%d:%d = %s %s\nAddress:  0x%x\n" % (self.type, self.material, water, tree_type, self.address)
        
        return s

def _alloc_tree_buffer_callback(ptr, count):
    return util._allocate_array(ptr, Tree, count)

_alloc_tree_buffer_functype = CFUNCTYPE(c_int, POINTER(POINTER(Tree)), c_uint)
_alloc_tree_buffer_func = _alloc_tree_buffer_functype(_alloc_tree_buffer_callback)
_register_callback("alloc_tree_buffer_callback", _alloc_tree_buffer_func)

class Material(Structure):
    _fields_ = [("itemType", c_short),
                ("subType", c_short),
                ("subIndex", c_short),
                ("index", c_int),
                ("flags", c_uint)]

def _alloc_material_buffer_callback(ptr, count):
    return util._allocate_array(ptr, Material, count)

_material_functype = CFUNCTYPE(c_int, POINTER(POINTER(Material)), c_uint)
_material_func = _material_functype(_alloc_material_buffer_callback)
_register_callback("alloc_material_buffer_callback", _material_func)

class Skill(Structure):
    _fields_ = [("id", c_uint),
                ("experience", c_uint),
                ("rating", c_uint)]

class Job(Structure):
    _fields_ = [("active", c_byte),
                ("jobId", c_uint),
                ("jobType", c_ubyte),
                ("occupationPtr", c_uint)]

class Like(Structure):
    _fields_ = [("type", c_short),
                ("itemClass", c_short),
                ("itemIndex", c_short),
                ("material", MatglossPair),
                ("active", c_byte)]

class Attribute(Structure):
    _fields_ = [("level", c_uint),
                ("field_4", c_uint),
                ("field_8", c_uint),
                ("field_C", c_uint),
                ("leveldiff", c_uint),
                ("field_14", c_uint),
                ("field_18", c_uint)]

class Name(Structure):
    _fields_ = [("first_name", _dfhack_string),
                ("nickname", _dfhack_string),
                ("words", (c_int * 7)),
                ("parts_of_speech", (c_ushort * 7)),
                ("language", c_uint),
                ("has_name", c_byte)]

class Note(Structure):
    _fields_ = [("symbol", c_char),
                ("foreground", c_ushort),
                ("background", c_ushort),
                ("name", _dfhack_string),
                ("x", c_ushort),
                ("y", c_ushort),
                ("z", c_ushort)]

class Settlement(Structure):
    _fields_ = [("origin", c_uint),
                ("name", Name),
                ("world_x", c_short),
                ("world_y", c_short),
                ("local_x1", c_short),
                ("local_x2", c_short),
                ("local_y1", c_short),
                ("local_y2", c_short)]

_NUM_CREATURE_TRAITS = 30
_NUM_CREATURE_LABORS = 102

class Soul(Structure):
    _fields_ = [("numSkills", c_ubyte),
                ("skills", (Skill * 256)),
                ("traits", (c_ushort * _NUM_CREATURE_TRAITS)),
                ("analytical_ability", Attribute),
                ("focus", Attribute),
                ("willpower", Attribute),
                ("creativity", Attribute),
                ("intuition", Attribute),
                ("patience", Attribute),
                ("memory", Attribute),
                ("linguistic_ability", Attribute),
                ("spatial_sense", Attribute),
                ("musicality", Attribute),
                ("kinesthetic_sense", Attribute),
                ("empathy", Attribute),
                ("social_awareness", Attribute)]

_MAX_COLORS = 15

class Creature(Structure):
    _fields_ = [("origin", c_uint),
                ("x", c_ushort),
                ("y", c_ushort),
                ("z", c_ushort),
                ("race", c_uint),
                ("civ", c_int),
                ("flags1", CreatureFlags1),
                ("flags2", CreatureFlags2),
                ("name", Name),
                ("mood", c_short),
                ("mood_skill", c_short),
                ("artifact_name", Name),
                ("profession", c_ubyte),
                ("custom_profession", _dfhack_string),
                ("labors", (c_ubyte * _NUM_CREATURE_LABORS)),
                ("current_job", Job),
                ("happiness", c_uint),
                ("id", c_uint),
                ("strength", Attribute),
                ("agility", Attribute),
                ("toughness", Attribute),
                ("endurance", Attribute),
                ("recuperation", Attribute),
                ("disease_resistance", Attribute),
                ("squad_leader_id", c_int),
                ("sex", c_ubyte),
                ("caste", c_ushort),
                ("pregnancy_timer", c_uint),
                ("has_default_soul", c_byte),
                ("defaultSoul", Soul),
                ("nbcolors", c_uint),
                ("color", (c_uint * _MAX_COLORS)),
                ("birth_year", c_int),
                ("birth_time", c_uint)]

class CreatureExtract(Structure):
    _fields_ = [("rawname", _dfhack_string)]

class BodyPart(Structure):
    _fields_ = [("id", _dfhack_string),
                ("category", _dfhack_string),
                ("single", _dfhack_string),
                ("plural", _dfhack_string)]

_bodypart_ptr = POINTER(BodyPart)

class ColorModifier(Structure):
    _fields_ = [("part", _dfhack_string),
                ("colorlist", POINTER(c_uint)),
                ("colorlistLength", c_uint),
                ("startdate", c_uint),
                ("enddate", c_uint)]

    def __init__(self):
        self.colorlistLength = 0

_colormodifier_ptr = POINTER(ColorModifier)

class CreatureCaste(Structure):
    _fields_ = [("rawname", _dfhack_string),
                ("singular", _dfhack_string),
                ("plural", _dfhack_string),
                ("adjective", _dfhack_string),
                ("color_modifier", _colormodifier_ptr),
                ("color_modifier_length", c_uint),
                ("bodypart", _bodypart_ptr),
                ("bodypart_length", c_uint),
                ("strength", Attribute),
                ("agility", Attribute),
                ("toughness", Attribute),
                ("endurance", Attribute),
                ("recuperation", Attribute),
                ("disease_resistance", Attribute),
                ("analytical_ability", Attribute),
                ("focus", Attribute),
                ("willpower", Attribute),
                ("creativity", Attribute),
                ("intuition", Attribute),
                ("patience", Attribute),
                ("memory", Attribute),
                ("linguistic_ability", Attribute),
                ("spatial_sense", Attribute),
                ("musicality", Attribute),
                ("kinesthetic_sense", Attribute)]

_creaturecaste_ptr = POINTER(CreatureCaste)

class TileColor(Structure):
    _fields_ = [("fore", c_ushort),
                ("back", c_ushort),
                ("bright", c_ushort)]

class ColorDescriptor(Structure):
    _fields_ = [("colorlistLength", c_uint)]

class CasteDescriptor(Structure):
    _fields_ = [("color_descriptors", POINTER(ColorDescriptor)),
                ("colorModifierLength", c_uint),
                ("bodypartLength", c_uint)]

class CreatureTypeDescriptor(Structure):
    _fields_ = [("caste_descriptors", POINTER(CasteDescriptor)),
                ("castesCount", c_uint),
                ("extractCount", c_uint)]

class CreatureType(Structure):
    _fields_ = [("rawname", _dfhack_string),
                ("castes", _creaturecaste_ptr),
                ("castes_count", c_uint),
                ("extract", POINTER(CreatureExtract)),
                ("extract_count", c_uint),
                ("tile_character", c_ubyte),
                ("tilecolor", TileColor)]

_creaturetype_ptr = POINTER(CreatureType)

def _alloc_creaturetype_buffer(ptr, descriptors, count):
    arr_list = []
    c_arr = (CreatureType * count)()
    
    for i, v in enumerate(c_arr):
        v.castesCount = descriptors[i].castesCount
        v_caste_arr = (CreatureCaste * v.castesCount)()
        
        for j, v_c in enumerate(v_caste_arr):
            caste_descriptor = descriptors[i].caste_descriptors[j]
            
            v_c.colorModifierLength = caste_descriptor.colorModifierLength
            c_color_arr = (ColorModifier * v_c.colorModifierLength)()
            
            for k, c_c in enumerate(c_color_arr):
                color_descriptor = caste_descriptor.color_descriptors[k]
                
                c_c.colorlistLength = color_descriptor.colorlistLength
                
                c_color_list_arr = (c_uint * c_c.colorlistLength)()
                
                p = cast(c_color_list_arr, POINTER(c_uint))
                
                c_c.colorlist = p
                
                arr_list.extend((c_color_list_arr, p))
            
            c_p = cast(c_color_arr, POINTER(ColorModifier))
            v_c.colorModifier = c_p
            
            v_c.bodypartLength = caste_descriptor.bodypartLength
            c_bodypart_arr = (BodyPart * v_c.bodypartLength)()
            
            b_p = cast(c_bodypart_arr, POINTER(BodyPart))
            v_c.bodypart = b_p
            
            arr_list.extend((c_color_arr, c_p, c_bodypart_arr, b_p))
        
        v.extractCount = descriptors[i].extractCount
        v_extract_arr = (CreatureExtract * v.extractCount)()
        
        caste_p = cast(v_caste_arr, POINTER(CreatureCaste))        
        v.castes = caste_p
        
        extract_p = cast(v_extract_arr, POINTER(CreatureExtract))
        v.extract = extract_p
        
        arr_list.extend((v_caste_arr, caste_p, v_extract_arr, extract_p))
    
    p = cast(c_arr, _creaturetype_ptr)
    ptr[0] = p
    
    pointer_dict[addressof(c_arr)] = (ptr, c_arr, p, arr_list)
    
    return 1

_alloc_creaturetype_buffer_functype = CFUNCTYPE(c_int, POINTER(_creaturetype_ptr), POINTER(CreatureTypeDescriptor), c_uint)
_alloc_creaturetype_buffer_func = _alloc_creaturetype_buffer_functype(_alloc_creaturetype_buffer)
_register_callback("alloc_creaturetype_buffer_callback", _alloc_creaturetype_buffer_func)

class GameModes(Structure):
    _fields_ = [("control_mode", c_ubyte),
                ("game_mode", c_ubyte)]

class Hotkey(Structure):
    _fields_ = [("name", (c_char * 10)),
                ("mode", c_short),
                ("x", c_int),
                ("y", c_int),
                ("z", c_int)]

_hotkey_ptr = POINTER(Hotkey)

def _alloc_hotkey_buffer_callback(ptr, count):
    print "hotkey alloc:  %d" % count
    return util._allocate_array(ptr, Hotkey, count)

_hotkey_functype = CFUNCTYPE(c_int, POINTER(_hotkey_ptr), c_uint)
_hotkey_func = _hotkey_functype(_alloc_hotkey_buffer_callback)
_register_callback("alloc_hotkey_buffer_callback", _hotkey_func)

class MemRange(Structure):
    _fields_ = [("start", c_ulong),
                ("end", c_ulong),
                ("name", (c_char * 1024)),
                ("read", c_uint, 1),
                ("write", c_uint, 1),
                ("execute", c_uint, 1),
                ("shared", c_uint, 1),
                ("valid", c_ubyte),
                ("buffer", POINTER(c_ubyte))]

_memrange_ptr = POINTER(MemRange)

def _alloc_memrange_buffer(ptr, descriptors, count):
    arr_list = []
    m_arr = (MemRange * count)()
    
    for i, v in enumerate(m_arr):
        buf_arr = (c_ubyte * int(descriptors[i]))()
        buf_ptr = cast(buf_arr, POINTER(c_ubyte))
        
        v.buffer = buf_ptr
        
        arr_list.extend((buf_arr, buf_ptr))
    
    p = cast(m_arr, _memrange_ptr)
    ptr[0] = p
    
    pointer_dict[addressof(m_arr)] = (ptr, m_arr, p, arr_list)
    
    return 1

_alloc_memrange_buffer_functype = CFUNCTYPE(c_int, POINTER(_memrange_ptr), POINTER(c_uint), c_uint)
_alloc_memrange_buffer_func = _alloc_memrange_buffer_functype(_alloc_memrange_buffer)
_register_callback("alloc_memrange_buffer_callback", _alloc_memrange_buffer_func)