//input prim name
    //result: we sit on that prim
    public class SitManager
    {
        Dictionary<LLUUID, Primitive> PrimsWaiting = new Dictionary<LLUUID, Primitive>();
        AutoResetEvent AllPropertiesReceived = new AutoResetEvent(false);
        SecondLife client;
        
        bool done = false;
        bool sitting = false;

        public bool Sitting
        {
            get { return sitting; }
        }

        System.Timers.Timer giveup;

        private bool ALWAYS_REQUEST_OBJECTS;
        private bool ALWAYS_DECODE_OBJECTS;
        private bool OBJECT_TRACKING;
        private float camera;
        private ObjectManager om;

        public SitManager(string target, SecondLife _client, int expiry)
        {
            client = _client;

            ALWAYS_REQUEST_OBJECTS = client.Settings.ALWAYS_REQUEST_OBJECTS;
            ALWAYS_DECODE_OBJECTS = client.Settings.ALWAYS_DECODE_OBJECTS;
            OBJECT_TRACKING = client.Settings.OBJECT_TRACKING;
            camera = client.Self.Movement.Camera.Far;

            client.Settings.ALWAYS_REQUEST_OBJECTS = true;
            client.Settings.ALWAYS_DECODE_OBJECTS = true;
            client.Settings.OBJECT_TRACKING = true;
            client.Self.Movement.Camera.Far = 64;
            om = new ObjectManager(client);
            client.Objects.OnObjectProperties += new ObjectManager.ObjectPropertiesCallback(Objects_OnObjectProperties);
            LocateSeat(target);

            client.Settings.ALWAYS_REQUEST_OBJECTS = ALWAYS_REQUEST_OBJECTS;
            client.Settings.ALWAYS_DECODE_OBJECTS = ALWAYS_DECODE_OBJECTS;
            client.Settings.OBJECT_TRACKING = OBJECT_TRACKING;
            client.Self.Movement.Camera.Far = camera;

            giveup = new System.Timers.Timer(expiry * 1000);
            giveup.Elapsed += new ElapsedEventHandler(giveup_Elapsed);
            giveup.Start();

        }

        void giveup_Elapsed(object sender, ElapsedEventArgs e)
        {
            done = true;
        }


        private void LocateSeat(string target)
        {
            LLVector3 location = client.Self.SimPosition;
            List<Primitive> prims = client.Network.CurrentSim.ObjectsPrimitives.FindAll(
            delegate(Primitive prim)
            {
                LLVector3 pos = prim.Position;
                return ((prim.ParentID == 0) && (pos != LLVector3.Zero) && prim.Properties.Name == null);
            }
            );
            while (!done)
            {
                bool complete = RequestObjectProperties(prims, 250);
                double heading = -Math.PI;

                foreach (Primitive p in prims)
                {
                    string name = p.Properties.Name;
                    if (name != null && name.Contains(target))
                    {
                        
                        client.Self.RequestSit(p.Properties.ObjectID, LLVector3.Zero);
                        sitting = true;
                        done = true;
                    }
                }

                prims = client.Network.CurrentSim.ObjectsPrimitives.FindAll(
                    delegate(Primitive prim)
                    {
                        LLVector3 pos = prim.Position;
                        return ((prim.ParentID == 0) && (pos != LLVector3.Zero) && prim.Properties.Name == null);
                    }
                );

                if (prims.Count == 0)
                {
                    heading += 0.5d;
                    if (heading > Math.PI) heading = -Math.PI;

                    client.Self.Movement.UpdateFromHeading(heading, false);

                }
            }
        }


        private bool RequestObjectProperties(List<Primitive> objects, int msPerRequest)
        {
            // Create an array of the local IDs of all the prims we are requesting properties for
            uint[] localids = new uint[objects.Count];

            lock (PrimsWaiting)
            {
                PrimsWaiting.Clear();

                for (int i = 0; i < objects.Count && i < 25; ++i)
                {
                    localids[i] = objects[i].LocalID;
                    if (!PrimsWaiting.ContainsKey(objects[i].ID))
                    {
                        PrimsWaiting.Add(objects[i].ID, objects[i]);
                    }
                }
            }

            client.Objects.SelectObjects(client.Network.CurrentSim, localids);

            return AllPropertiesReceived.WaitOne(5000 + msPerRequest * objects.Count, false);
        }

        private void Objects_OnObjectProperties(Simulator simulator, LLObject.ObjectProperties properties)
        {
            lock (PrimsWaiting)
            {
                Primitive prim;
                if (PrimsWaiting.TryGetValue(properties.ObjectID, out prim))
                {
                    prim.Properties = properties;
                }
                PrimsWaiting.Remove(properties.ObjectID);

                if (PrimsWaiting.Count == 0)
                    AllPropertiesReceived.Set();
            }
        }
    }