using System;
using System.IO;
using System.Linq;
using System.Threading;
using Db4objects.Db4o;
using Db4objects.Db4o.CS;
using Db4objects.Db4o.Linq;

namespace Db4OSeries
{
    public class Program
    {
        internal static void Main(string[] args)
        {
            {
                using (var server = CreateServer())
                {
                    RefCache(server);
                }
                using (var server = CreateServer())
                {
                    ReadCommited(server);
                }
                using (var server = CreateServer())
                {
                    RefCache2(server);
                }
                using (var server = CreateServer())
                {
                    Locking(server);
                }
            }


            Console.ReadKey();
        }

        private static void Locking(IObjectServer server)
        {
            const int timeOut = 100;
            var client1 = server.OpenClient();
            var client2 = server.OpenClient();
            if (!client1.Ext().SetSemaphore("lock-demo", timeOut))
            {
                throw new InvalidOperationException("Expect that I can get lock");
            }
            var couldGetLockOnClient1 = false;
            var couldGetLockOnClient2 = false;
            var thread = new Thread(() =>
                                        {
                                            couldGetLockOnClient1 = client1.Ext().SetSemaphore("lock-demo",
                                                                                               timeOut);
                                            couldGetLockOnClient2 = client2.Ext().SetSemaphore("lock-demo",
                                                                                               timeOut);
                                        });
            thread.Start();
            thread.Join();
            AssertTrue(couldGetLockOnClient1, "client1 can get lock. Also in other threads");
            AssertTrue(couldGetLockOnClient2, "client2 cannot get lock, since it's hold be client2");
        }

        private static void DoWork()
        {
            throw new NotImplementedException();
        }

        private static void RefCache2(IObjectServer server)
        {
            FillDB(server);
            var client1 = server.OpenClient();
            var client2 = server.OpenClient();
            var objFromClient1 = LoadObjectByName(client1, "old-name");
            var objFromClient2 = LoadObjectByName(client2, "old-name");
            AssertTrue(objFromClient1.Name == objFromClient2.Name, "Names are equal");

            objFromClient1.Name = "new-name";
            client1.Store(objFromClient1);
            client1.Commit();

            objFromClient2 = LoadObjectByName(client2, "new-name");
            // fails, because its still in the cache
            AssertTrue("new-name" == objFromClient2.Name, "Names are equal");
// refreshing
            const int activationDeph = 4;
            client2.Ext().Refresh(objFromClient2, activationDeph);
            AssertTrue("new-name" == objFromClient2.Name, "Names are equal");
        }

        private static SimpleObject LoadObjectByName(IObjectContainer client1, string name)
        {
            return (from SimpleObject o in client1
                    where o.Name == name
                    select o).Single();
        }

        private static void RefCache(IObjectServer server)
        {
            FillDB(server);
            var client1 = server.OpenClient();
            var client2 = server.OpenClient();
            var objFromClient1 = (from SimpleObject o in client1
                                  where o.Name == "first-Obj"
                                  select o).Single();
            var objFromClient2 = (from SimpleObject o in client2
                                  where o.Name == "first-Obj"
                                  select o).Single();
            AssertTrue(ReferenceEquals(objFromClient1, objFromClient2), "Have a shared reference-cache");
        }

        private static void FillDB(IObjectServer server)
        {
            using (var db = server.OpenClient())
            {
                db.Store(new SimpleObject("first-Obj", 2, 2));
                db.Store(new SimpleObject("second-Obj", 3, 3));
                db.Store(new SimpleObject("old-name", 3, 3));
            }
        }

        private static IObjectServer CreateServer()
        {
            const string FilePath = "database.db4o";
            File.Delete(FilePath);
            const int RunEmbeddedServer = 0;
            return Db4oClientServer.OpenServer(FilePath, RunEmbeddedServer);
        }

        private static void ReadCommited(IObjectServer server)
        {
            var client1 = server.OpenClient();
            var client2 = server.OpenClient();

            client1.Store(new SimpleObject("first-Obj", 2, 2));
            client1.Store(new SimpleObject("second-Obj", 3, 3));

            var countBeforeCommit = (from SimpleObject o in client2
                                     select o).Count();
            AssertTrue(0 == countBeforeCommit, "Doesn't see stuff from first client");

            client1.Commit();

            var countAfterCommit = (from SimpleObject o in client2
                                    select o).Count();
            AssertTrue(2 == countAfterCommit, "After commit it does see the stuff from the first client");
        }

        private static void AssertTrue(bool b, string explenation)
        {
            if (!b)
            {
                Console.Out.WriteLine("Assert FAILED:" + explenation);
            }
            else
            {
                Console.Out.WriteLine("Assert successful:" + explenation);
            }
        }
    }
}