#
# Copyright (c) 2004, 2005, 2006 Art Haas
#
# This file is part of PythonCAD.
#
# PythonCAD is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# PythonCAD is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with PythonCAD; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#
# _The_ base class for all objects used in PythonCAD
#

import types

from PythonCAD.Generic import message
from PythonCAD.Generic import logger
from PythonCAD.Generic import util

class Entity(message.Messenger):
    """The base class for PythonCAD entities.

An entity has the following properties:

parent: The parent of an entity - another entity or None

An entity has the following methods:

{set/get}Lock(): Set/Get the locked state on an entity.
isLocked(): Returns the locked state of an entity.
isModified(): Returns the flag indicating the entity has been modified.
modified()/reset(): Set/Unset a flag indicating the entity modified state.
isVisible(): Returns the visibity of the entity.
{set/get}Visibility(): Set/Get the visibility flag on an entity.
{set/get}Parent(): Set/Get the parent entity of an entity.
{add/del}Child(): Add/Remove a child entity to/from another entity.
hasChild(): Test if one entity is a child of another.
hasChildren(): Test if an entity has any children entities.
getChildren(): Return a list of children entities for an entity.

A few short aliases exist for some of these methods:
lock(): Same as setLock(True)
unlock(): Same as setLock(False)
hide(): Same as setVisibility(True)
show()/expose(): Same as setVisibility(False)

The aliases may be removed at some point.
    """
    __messages = {
        'lock_changed' : True,
        'modified' : True,
        'reset' : True,
        # 'parent_changed' : True,
        'visibility_changed' : True,
        'refresh' : True,
        'added_child' : True,
        'removed_child' : True,
        'change_pending' : True,
        'change_complete' : True,
        }

    __idcount = 0

    def __init__(self, **kw):
        _parent = _id = None
        if 'parent' in kw:
            _parent = kw['parent']
            if _parent is not None and not isinstance(_parent, Entity):
                raise TypeError, "Unexpected parent type: " + `type(_parent)`
        if 'id' in kw:
            _id = kw['id']
            if not isinstance(_id, int):
                raise TypeError, "Unexpected ID type: " + `type(_id)`
            if _id < 0 or _id >= Entity.__idcount:
                raise ValueError, "Invalid ID: %d" % _id
        if _id is None:
            _id = Entity.__idcount
            Entity.__idcount = Entity.__idcount + 1
        super(Entity, self).__init__()
        self.__locked = False
        self.__modified = False
        self.__visible = True
        self.__parent = None
        self.__children = None
        self.__log = None
        self.__undoing = 0 # 1 => undo, -1 => redo
        self.__id = _id
        if _parent is not None:
            Entity.setParent(self, _parent)

    def finish(self):
        if self.__parent is not None:
            print "parent is not None: " + `self`
            print "parent: " + `self.__parent`
        if self.__children is not None:
            print "children is not None: " + `self`
            for _child in self.__children.values():
                print "Child: " + `_child`
        super(Entity, self).finish()

    def getValues(self):
        """Return values comprising the Entity.

getValues()

This method returns an EntityData instance.
        """
        _data = EntityData()
        _data.setValue('id', self.__id)
        _pid = None
        if self.__parent is not None:
            _pid = self.__parent.getID()
        _data.setValue('pid', _pid)
        return _data

    values = property(getValues, None, None, "Entity values")

    def getID(self):
        """Return the unique integer identifier for the entity.

getID()
        """
        return self.__id

    id = property(getID, None, None, "Entity ID")

    def isLocked(self):
        """Test if the entity has been locked.

isLocked()

This method returns a boolean.
        """
        return self.__locked

    def lock(self):
        """Set the entity so that its attributes cannot be changed.

lock()
        """
        Entity.setLock(self, True)

    def unlock(self):
        """Set the entity so that its attributes can be changed.

unlock()
        """
        Entity.setLock(self, False)

    def getLock(self):
        """Return the locked status of an entity.

getLock()        
        """
        return self.__locked
    
    def setLock(self, lock):
        """Set the locked status on an entity.

setLock(lock)

Argument 'lock' can be True or False.
        """
        util.test_boolean(lock)
        _l = self.__locked
        if _l is not lock:
            self.__locked = lock
            self.sendMessage('lock_changed', _l)
            self.modified()
        
    def isModified(self):
        """Test if the entity has been altered in some form.

isModified()

This method returns a boolean.
        """
        return self.__modified

    def startChange(self, msg):
        """Enter the modification state of an entity.

startChange(msg)

Argument 'msg' is the message the entity will send at the completion
of the modification.
        """
        if not self.sendsMessage(msg):
            raise ValueError, "Unknown message: %s" % msg
        self.sendMessage('change_pending', msg)

    def endChange(self, msg):
        """Complete the modification state of an entity.

endChange(msg)

This method is meant to complete the notification process begun
by the startChange() method.
        """
        if not self.sendsMessage(msg):
            raise ValueError, "Unknown message: %s" % msg
        self.sendMessage('change_complete', msg)
        
    def modified(self):
        """Indicate that the entity has been altered.

modified()
        """
        if not self.__modified:
            self.__modified = True
        self.sendMessage('modified')

    def reset(self):
        """Indicate that the entity is no longer altered.

reset()
        """
        if self.__modified:
            self.__modified = False
        self.sendMessage('reset')

    def isVisible(self):
        """Test to see if the entity can be seen.

isVisible()

This method returns a boolean.
        """
        return self.__visible is True

    def getVisibility(self):
        """Return the visibility flag of an entity.

getVisibility()        
        """
        return self.__visible
    
    def setVisibility(self, vis):
        """Set the visibility of the entity.

setVisibility(vis)

Argument 'vis' must be either True or False.
        """
        util.test_boolean(vis)
        _v = self.__visible
        if _v is not vis:
            self.startChange('visibility_changed')
            self.__visible = vis
            self.endChange('visibility_changed')
            self.sendMessage('visibility_changed', _v)
            self.modified()

    def hide(self):
        """Mark the entity invisible.

hide()
        """
        Entity.setVisibility(self, False)

    def show(self):
        """Mark the entity as visible.

show()
        """
        Entity.setVisibility(self, True)

    def expose(self):
        """Mark the entity as visible.

expose()

This method is identical to show().
        """
        Entity.setVisibility(self, True)

    def canParent(self, obj):
        """Test if an Entity can be the parent of another Entity.

canParent(obj)

Subclasses should override this method if the ability to be
the parent of another entity needs refinement.
        """
        return True

    def setParent(self, parent):
        """Store the parent of the entity.

setParent(parent)

Argument 'parent' must be another entity, and the parent
entity is tested to ensure that it can have children entities.
        """
        if parent is not None:
            if not isinstance(parent, Entity):
                raise TypeError, "Unexpected parent type: " + `type(parent)`
            if not parent.canParent(self):
                raise ValueError, "Invalid parent for Entity: " + `parent`
        _oldparent = self.__parent
        if _oldparent is not parent:
            if _oldparent is not None:
                Entity.__delChild(_oldparent, self)
            self.__parent = parent
            if parent is not None:
                Entity.__addChild(parent, self)
            #
            # fixme - re-examine sending (or not) the 'parent_changed'
            # and 'modified' messages when this method is invoked as this
            # method invocation is often called as part of an add/delete
            # operation that and as such can be thought of as a "side-effect"
            #
            # self.sendMessage('parent_changed', _oldparent)
            # self.modified()

    def getParent(self):
        """Return the parent entity of an entity.

getParent()

This method returns an Entity instance, or None of no
parent has been set.
        """
        return self.__parent

    parent = property(getParent, setParent, None, "Parent of an Entity.")

    def __addChild(self, child):
        """Take an entity as a child.

addChild(child)

This method is private to the Entity class.
        """
        if not isinstance(child, Entity):
            raise TypeError, "Unexpected child type: " + `type(child)`
        if child.getParent() is not self:
            raise ValueError, "Invalid parent: " + `child`
        if self.__children is None:
            self.__children = {}
        _cid = id(child)
        if _cid in self.__children:
            raise ValueError, "Child entity already stored: " + `child`
        self.__children[_cid] = child
        self.sendMessage('added_child', child)
        self.modified()

    def __delChild(self, child):
        """Remove an entity as a child.

delChild(child)

This method is private to the Entity class.
        """
        if child.getParent() is not self:
            raise ValueError, "Invalid parent for child: " + `child`
        if self.__children is None:
            raise ValueError, "Entity has no children: " + `self`
        _cid = id(child)
        if _cid not in self.__children:
            raise ValueError, "Child entity not stored: " + `child`
        del self.__children[_cid]
        if len(self.__children) == 0:
            self.__children = None
        self.sendMessage('removed_child', child)
        self.modified()

    def hasChild(self, child):
        """Test if an entity is a stored as a child.

hasChild(child)
        """
        return self.__children is not None and id(child) in self.__children

    def hasChildren(self):
        """Test if an entity has children entities.

hasChildren()

This method returns a boolean.
        """
        return self.__children is not None

    def getChildren(self):
        """Return any children entities of an entity.

getChildren()

This method returns a list of children entities.
        """
        if self.__children is not None:
            return self.__children.values()
        return []

    def sendsMessage(self, m):
        """Test if an entity can send a type of message.

sendsMessage(m)

Argument 'm' should be a string giving the message name.
This method returns a boolean.
        """
        if m in Entity.__messages:
            return True
        return super(Entity, self).sendsMessage(m)

    def clone(self):
        """Return an identical copy of an entity.

clone()
        """
        return Entity(parent=self.__parent)

    def inRegion(self, xmin, ymin, xmax, ymax, all=False):
        """Test if an entity is found in a spatial region.

inRegion(xmin, ymin, xmax, ymax[, all])

Arguments 'xmin', 'ymin', 'xmax', and 'ymax' should all be
floats. Argument 'all' is a boolean, with the default set
to False. If 'all' is true, then the entire entity must
lie within the boundary.
        """
        return False

    def getLog(self):
        """Return the history log for an entity.

getLog()

This method returns a Logger instance, or None if no log
has been assigned to the entity.
        """
        return self.__log

    def setLog(self, log):
        """Assign a Logger instance to an entity.

setLog(log)

Argument 'log' should be a Logger instance, or None.
        """
        if log is not None:
            if not isinstance(log, logger.Logger):
                raise TypeError, "Unexpected log type: " + `type(log)`
            if self.__log is not None:
                raise ValueError, "Entity already contains a log."
        self.__log = log

    def delLog(self):
        """Remove a Logger instance from an entity.

delLog()
        """
        if self.__log is not None:
            self.__log.clear()
        self.__log = None

    def undo(self):
        """Undo an action.

undo()

Using undo() requires a Logger instance to be assigned to the entity.
        """
        if self.__log is not None:
            self.__log.undo()

    def startUndo(self, mute=False):
        """Store an indication that an undo operation is commencing.

startUndo([mute])

Optional argument 'mute' must be a boolean. By default it is False, and
when True the entity will be muted during the undo operation.
        """
        _state = self.__undoing
        if _state != 0:
            if _state == -1:
                raise RuntimeError, "Object in redo state: " + `self`
            elif _state == 1:
                raise RuntimeError, "Object already in undo state: " + `self`
            else:
                raise ValueError, "Unexpected undo/redo state: %d" % _state
        if mute and False:
            self.mute()
        self.__undoing = 1

    def endUndo(self):
        """Set the entity to the state of undo operation completion.

endUndo()
        """
        _state = self.__undoing
        if _state != 1:
            if _state == -1:
                raise RuntimeError, "Object in redo state: " + `self`
            elif _state == 0:
                raise RuntimeError, "Object not in undo state: " + `self`
            else:
                raise ValueError, "Unexpected undo/redo state: %d" % _state
        self.__undoing = 0

    def inUndo(self):
        """Test if the entity is currently in an undo operation.

inUndo()

This method returns a boolean.
        """
        return self.__undoing == 1

    def redo(self):
        """Redo an action.

redo()

Using redo() requires a Logger instance to be assigned to the entity.
        """
        if self.__log is not None:
            self.__log.redo()

    def startRedo(self):
        """Store an indication that an redo operation is commencing.

startRedo()

        """
        _state = self.__undoing
        if _state != 0:
            if _state == 1:
                raise RuntimeError, "Object in undo state: " + `self`
            elif _state == -1:
                raise RuntimeError, "Object already in redo state: " + `self`
            else:
                raise ValueError, "Unexpected undo/redo state: %d" % _state
        self.__undoing = -1

    def endRedo(self):
        """Set the entity to the state of redo operation completion.

endRedo()
        """
        _state = self.__undoing
        if _state != -1:
            if _state == 1:
                raise RuntimeError, "Object in undo state: " + `self`
            elif _state == 0:
                raise RuntimeError, "Object not in redo state: " + `self`
            else:
                raise ValueError, "Unexpected undo/redo state: %d" % _state
        self.__undoing = 0

    def inRedo(self):
        """Test if the entity is currently in a redo operation.

inRedo()

This method returns a boolean.
        """
        return self.__undoing == -1

#
# Entity history class
#

class EntityLog(logger.Logger):
    def __init__(self, obj):
        if not isinstance(obj, Entity):
            raise TypeError, "Unexpected entity type: " + `type(obj)`
        super(EntityLog, self).__init__()
        self.__obj = obj
        obj.connect('visibility_changed', self.__visibilityChanged)
        obj.connect('lock_changed', self.__lockChanged)
        # obj.connect('parent_changed', self.__parentChanged)

    def detatch(self):
        self.__obj.disconnect(self)
        self.__obj = None

    def getObject(self):
        """Return the object stored in the log.

getEntity()        
        """
        return self.__obj
    
    def __visibilityChanged(self, obj, *args):
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _vis = args[0]
        util.test_boolean(_vis)
        self.saveUndoData('visibilty_changed', _vis)

    def __lockChanged(self, obj, *args):
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _lock = args[0]
        util.test_boolean(_lock)
        self.saveUndoData('lock_changed', _lock)
        
    def __parentChanged(self, obj, *args):
        _alen = len(args)
        if _alen < 1:
            raise ValueError, "Invalid argument count: %d" % _alen
        _parent = args[0]
        if _parent is not None and not isinstance(_parent, Entity):
            raise TypeError, "Unexpected parent type: " + `type(_parent)`
        _pid = None
        if _parent is not None:
            _pid = _parent.getID()
        self.saveUndoData('parent_changed', _pid)

    def execute(self, undo, *args):
        # print "EntityLog::execute() ..."
        # print args
        util.test_boolean(undo)
        _alen = len(args)
        if len(args) == 0:
            raise ValueError, "No arguments to execute()"
        _obj = self.__obj
        _op = args[0]
        if _op == 'visibility_changed':
            if len(args) < 2:
                raise ValueError, "Invalid argument count: %d" % _alen
            _sdata = _obj.getVisibility()
            self.ignore(_op)
            try:
                _vis = args[1]
                if undo:
                    _obj.startUndo()
                    try:
                        _obj.setVisibility(_vis)
                    finally:
                        _obj.endUndo()
                else:
                    _obj.startRedo()
                    try:
                        _obj.setVisibility(_vis)
                    finally:
                        _obj.endRedo()
            finally:
                self.receive(_op)
            self.saveData(undo, _op, _sdata)
        elif _op == 'lock_changed':
            if len(args) < 2:
                raise ValueError, "Invalid argument count: %d" % _alen
            _sdata = _obj.isLocked()
            self.ignore(_op)
            try:
                _lock = args[1]
                if undo:
                    _obj.startUndo()
                    try:
                        _obj.setLock(_lock)
                    finally:
                        _obj.endUndo()
                else:
                    _obj.startRedo()
                    try:
                        _obj.setLock(_lock)
                    finally:
                        _obj.endRedo()
            finally:
                self.receive(_op)
            self.saveData(undo, _op, _sdata)
        else:
            raise ValueError, "Unexpected operation: %s" % _op

    def saveData(self, undo, op, *args):
        util.test_boolean(undo)
        if undo:
            self.saveRedoData(op, *args)
        else:
            self.saveUndoData(op, *args)

#
# property storage class
#

class EntityData(object):
    def __init__(self):
        self.__values = {}
        self.__locked = False

    def keys(self):
        return self.__values.keys()

    def values(self):
        return self.__values.values()

    def lock(self):
        self.__locked = True

    def unlock(self):
        self.__locked = False

    def isLocked(self):
        return self.__locked is True

    def setValue(self, key, value):
        if self.__locked:
            raise RuntimeError, "EntityData instance is locked: " + `self`
        if not isinstance(key, types.StringTypes):
            raise TypeError, "Invalid key type: " + `type(key)`
        if not EntityData._testValueType(self, value):
            raise TypeError, "Invalid value type: " + `type(value)`
        self.__values[key] = value

    def _testValueType(self, value):
        _pass = isinstance(value, (types.StringTypes, types.NoneType, int, float, EntityData))
        if not _pass:
            if isinstance(value, (tuple, list)):
                for _v in value:
                    _pass = EntityData._testValueType(self, _v)
                    if not _pass:
                        break
            elif isinstance(value, dict):
                for _k, _v in value.items():
                    _pass = isinstance(_k, types.StringTypes)
                    if not _pass:
                        break
                    _pass = EntityData._testValueType(self, _v)
                    if not _pass:
                        break
            else:
                _pass = False
        return _pass

    def getValue(self, key):
        return self.__values[key]

    def get(self, key):
        return self.__values.get(key)