import os
import threading
import time
from ._compat import unittest
from ._adapt import IS_GAE
from pydal._compat import to_bytes
from pydal.contrib.portalocker import lock, unlock, read_locked, write_locked
from pydal.contrib.portalocker import LockedFile, LOCK_EX


def tearDownModule():
    if os.path.isfile('test.txt'):
        os.unlink('test.txt')

class testPortalocker(unittest.TestCase):

    def test_LockedFile(self):
        f = LockedFile('test.txt', mode='wb')
        f.write(to_bytes('test ok'))
        f.close()
        f = LockedFile('test.txt', mode='rb')
        self.assertEqual(f.read(), to_bytes('test ok'))
        f.close()

    @unittest.skipIf(IS_GAE, "GAE has no locks")
    def test_openmultiple(self):

        t0 = time.time()
        def worker1():
            start = time.time()
            f1 = LockedFile('test.txt', mode='ab')
            time.sleep(2)
            f1.write(to_bytes("%s\t%s\n" % (start, time.time())))
            f1.close()

        f = LockedFile('test.txt', mode='wb')
        f.write(to_bytes(''))
        f.close()
        th = []
        for x in range(10):
            t1 = threading.Thread(target=worker1)
            th.append(t1)
            t1.start()
        for t in th:
            t.join()
        with open('test.txt') as g:
            content = g.read()

        results = [line.strip().split('\t') for line in content.split('\n') if line]
        # all started at more or less the same time
        starts = [1 for line in results if float(line[0])-t0<1]
        ends = [line[1] for line in results]
        self.assertEqual(sum(starts), len(starts))
        # end - start is at least 2
        for line in results:
            self.assertTrue(float(line[1]) - float(line[0]) >= 2)
        # ends are not the same
        self.assertTrue(len(ends) == len(ends))

    @unittest.skipIf(IS_GAE, "GAE has no locks")
    def test_lock_unlock(self):

        def worker1(fh):
            time.sleep(2)
            unlock(fh)

        def worker2(fh):
            time.sleep(2)
            fh.close()

        f = open('test.txt', mode='wb')
        lock(f, LOCK_EX)
        f.write(to_bytes('test ok'))
        t1 = threading.Thread(target=worker1, args=(f, ))
        t1.start()
        start = int(time.time())
        content = read_locked('test.txt')
        end = int(time.time())
        t1.join()
        f.close()
        # it took at least 2 seconds to read
        # although nothing is there until .close()
        self.assertTrue(end - start >= 2)
        self.assertEqual(content, to_bytes(''))
        content = read_locked('test.txt')
        self.assertEqual(content, to_bytes('test ok'))

        f = LockedFile('test.txt', mode='wb')
        f.write(to_bytes('test ok'))
        t1 = threading.Thread(target=worker2, args=(f, ))
        t1.start()
        start = int(time.time())
        content = read_locked('test.txt')
        end = int(time.time())
        t1.join()
        # it took at least 2 seconds to read
        # content is there because we called close()
        self.assertTrue(end - start >= 2)
        self.assertEqual(content, to_bytes('test ok'))

    @unittest.skipIf(IS_GAE, "GAE has no locks")
    def test_read_locked(self):

        def worker(fh):
            time.sleep(2)
            fh.close()

        f = LockedFile('test.txt', mode='wb')
        f.write(to_bytes('test ok'))
        t1 = threading.Thread(target=worker, args=(f, ))
        t1.start()
        start = int(time.time())
        content = read_locked('test.txt')
        end = int(time.time())
        t1.join()
        # it took at least 2 seconds to read
        self.assertTrue(end - start >= 2)
        self.assertEqual(content, to_bytes('test ok'))

    @unittest.skipIf(IS_GAE, "GAE has no locks")
    def test_write_locked(self):

        def worker(fh):
            time.sleep(2)
            fh.close()

        f = open('test.txt', mode='wb')
        lock(f, LOCK_EX)
        t1 = threading.Thread(target=worker, args=(f, ))
        t1.start()
        start = int(time.time())
        write_locked('test.txt', to_bytes('test ok'))
        end = int(time.time())
        t1.join()
        with open('test.txt') as g:
            content = g.read()
        # it took at least 2 seconds to read
        self.assertTrue(end - start >= 2)
        self.assertEqual(content, 'test ok')

    def test_exception(self):
        self.assertRaises(RuntimeError, LockedFile, *['test.txt', 'x'])

    def test_readline(self):
        f = LockedFile('test.txt', 'wb')
        f.write(to_bytes('abc\n'))
        f.write(to_bytes('123\n'))
        f.close()
        f = LockedFile('test.txt', 'rb')
        rl = f.readline()
        self.assertTrue(to_bytes('abc') in rl)
        rl = f.readline()
        self.assertTrue(to_bytes('123') in rl)
        f.close()
        f = LockedFile('test.txt', 'rb')
        rls = f.readlines()
        f.close()
        self.assertEqual(len(rls), 2)