#!/usr/bin/env python
#-*- coding utf-8 -*-
import os
from decimal import Decimal

class Material(object):
    def __init__(self, name, rgb, amb, emis, spec, shi, trans):
        self.name = name
        self.rgb = rgb
        self.amb = amb
        self.emis = emis
        self.spec = spec
        self.shi = shi
        self.trans = trans

class Surf(object):
    def __init__(self, surf, mat, refs):
        self.s = surf
        self.mat = mat
        self.refs = refs

class Ref(object):
    def __init__(self, vert, uvx, uvy):
        self.v = vert
        self.uvx = uvx
        self.uvy = uvy

class World(object):
    def __init__(self, fh = None):
        self.kids = []
        if fh:
            self.parselines(fh)

    def parselines(self, fh):
        ln = fh.readline().strip()
        # the world object should only have kids
        assert ln.startswith('kids ')
        num_kids = int(ln.strip().lstrip('kids '))
        self._kids(fh, num_kids)

    def _kids(self, fh, num_kids):
        self.kids = []
        while num_kids > 0:
            ln = fh.readline().strip()
            if not ln:
                break
            elif ln.startswith('OBJECT '):
                #print (self.name if hasattr(self, 'name') else 'WORLD'), num_kids, ln
                object_type = ln.lstrip('OBJECT ')
                if object_type == 'group':
                    self.kids.append(Group(fh))
                elif object_type == 'poly':
                    self.kids.append(Poly(fh))
                else:
                    self.kids.append(Unknown(fh, object_type))
                num_kids -= 1

class Unknown(World):
    def __init__(self, fh = None, object_type = None):
        World.__init__(self)
        self.object_type = object_type
        self.content = ''
        if fh:
            self.parselines(fh)

    def parselines(self, fh):
        ln = fh.readline()
        while ln and not ln.startswith('kids '):
            ln = fh.readline()
            self.content += ln +'\r\n'
        if ln.strip().startswith('kids '):
            num_kids = int(ln.strip().lstrip('kids '))
            self._kids(fh, num_kids)

class Group(World):
    def __init__(self, fh = None):
        World.__init__(self)
        dec0 = Decimal ('0.0')
        dec1 = Decimal ('1.0')
        self.name = ''
        self.data = None
        self.loc = (dec0, dec0, dec0)
        self.rot = (dec1, dec0, dec0, dec0, dec1, dec0, dec0, dec0, dec1)
        self.url = ''
        self.texture = ''
        self.texrep = (dec1, dec1)
        if fh:
            self.parselines(fh)

    def parselines(self, fh):
        while True:
            ln = fh.readline().strip()
            if not ln:
                break
            elif ln.startswith('kids'):
                num_kids = int(ln.lstrip('kids '))
                self._kids(fh, num_kids)
                break
            elif ln.startswith('name '):
                self.name = ln.lstrip('name ').strip('"')
            elif ln.startswith('data '):
                num_chars = int(ln.lstrip('data '))
                self._data(fh, num_chars)
            elif ln.startswith('rot '):
                self._rot(ln)
            elif ln.startswith('loc '):
                self._loc(ln)
            elif ln.startswith('url '):
                self._url(ln)
            elif ln.startswith('texture '):
                self._texture(ln)
            elif ln.startswith('texrep '):
                self._texrep(ln)

    def _name(self, ln):
        self.name = ln.lstrip('name ').strip('"')

    def _data(self, fh, num_chars):
        self.data = ''
        while num_chars > 0:
            ln = fh.readline()
            if not ln:
                break
            self.data += ln.rstrip('\n').rstrip('\r')
            num_chars -= len(self.data)
        #print self.name, "*data*", self.data

    def _loc(self, ln):
        self.loc = tuple([Decimal(v) for v in ln.split()[1:4]])

    def _rot(self, ln):
        self.rot = tuple([Decimal(v) for v in ln.split()[1:10]])

    def _url(self, ln):
        self.url = ln.lstrip('url ')

    def _texture(self, ln):
        self.texture = ln.strip().lstrip('texture ').strip('"')

    def _texrep(self, ln):
        self.texrep = tuple([Decimal(v) for v in ln.split()[1:3]])

class Poly(Group):
    def __init__(self, fh = None):
        Group.__init__(self)
        self.verts = []
        self.surfs = []
        self.crease = None
        if fh:
            self.parselines(fh)

    def parselines(self, fh):
        while True:
            ln = fh.readline().strip()
            if not ln:
                break
            elif ln.startswith('kids'):
                num_kids = int(ln.lstrip('kids '))
                self._kids(fh, num_kids)
                break
            elif ln.startswith('name '):
                self._name(ln)
            elif ln.startswith('data '):
                num_chars = int(ln.lstrip('data '))
                self._data(fh, num_chars)
            elif ln.startswith('rot '):
                self._rot(ln)
            elif ln.startswith('loc '):
                self._loc(ln)
            elif ln.startswith('url '):
                self._url(ln)
            elif ln.startswith('texture '):
                self._texture(ln)
            elif ln.startswith('texrep '):
                self._texrep(ln)
            elif ln.startswith('crease '):
                self._crease(ln)
            elif ln.startswith('numvert '):
                num_verts = int(ln.lstrip('numvert '))
                self._verts(fh, num_verts)
            elif ln.startswith('numsurf '):
                num_surfs = int(ln.lstrip('numsurf '))
                self._surfs(fh, num_surfs)

    def _crease(self, ln):
        self.crease = Decimal(ln.strip().lstrip('crease '))

    def _verts(self, fh, num_verts):
        while num_verts  > 0:
            ln = fh.readline().strip()
            if not ln:
                break
            self.verts.append(tuple([Decimal(v) for v in ln.split()]))
            num_verts -= 1

    def _surfs(self, fh, num_surfs):
        while num_surfs:
            surf = None
            mat = None
            num_refs = 0
            refs = []
            ln = fh.readline().strip()
            if not ln:
                break
            elif ln.strip().startswith('SURF '):
                surf = ln.lstrip('SURF ')
            elif ln.strip().startswith('mat '):
                mat = int(ln.lstrip('mat '))
            elif ln.startswith('refs '):
                num_refs = int(ln.lstrip('refs '))
                while num_refs > 0:
                    ln = fh.readline().strip()
                    if not ln:
                        break
                    v, uvx, uvy = ln.strip().split()
                    refs.append(Ref(int(v), Decimal(uvx), Decimal(uvy)))
                    num_refs -= 1
                break
            self.surfs.append(Surf(surf, mat, refs))
            num_surfs -= 1


class Scene(object):
    def __init__(self, ac3d_file=None):
        self.materials = []
        self.root = None
        if ac3d_file:
            self.readfile(ac3d_file)

    def readfile(self, ac3d_file):
        fh = None
        if hasattr(ac3d_file, 'readline'):
            fh = ac3d_file
        elif os.path.exists(filename) and os.path.isfile(filename):
            fh = file(filename, 'r')
        ln = fh.readline().strip()
        assert ln.strip()[0:4] == "AC3D"
        while not self.root:
            ln = fh.readline().strip()
            if not ln:
                break
            elif ln.startswith('MATERIAL '):
                name = ln.lstrip('MATERIAL ').strip('"')
                rgb = tuple([Decimal(v) for v in ln.split('rgb')[1].split()[0:3]])
                amb = tuple([Decimal(v) for v in ln.split('amb')[1].split()[0:3]])
                emis = tuple([Decimal(v) for v in ln.split('emis')[1].split()[0:3]])
                spec = tuple([Decimal(v) for v in ln.split('spec')[1].split()[0:3]])
                shi = int(ln.split('shi')[1].split()[0])
                trans = Decimal(ln.split('trans')[1].split()[0])
                self.materials.append(Material(name, rgb, amb, emis, spec, shi, trans))
            elif ln.strip().startswith('OBJECT '):
                if ln.strip().startswith('OBJECT world'):
                    self.root = World(fh)
                elif ln.strip().startswith('OBJECT group'):
                    self.root = Group(fh)
                elif ln.strip().startswith('OBJECT poly'):
                    self.root = Poly(fh)
                else:
                    self.root = Unknown(fh)