from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks, Deferred

from Queue import deque

from iro.model.schema import User, Offer as DBOffer, Userright
from iro.model.message import SMS
from iro.model.status import Status
from iro.model.offer import offers
from iro.model.job import exJobs

from iro.controller.task import createJob, Task
from iro.controller.pool  import taskPool, dbPool

from iro.offer import Offer, Provider

from iro.error import NoRouteForTask,RejectRecipient
from iro.telnumber import Telnumber

from ..test_helpers.dbtestcase import DBTestCase

class TaskTestCase(DBTestCase):
    def setUp(self):
        DBTestCase.setUp(self)
        dbPool.start(reactor)

    def tearDown(self):
        exJobs.clear()
        offers.clear()
        dbPool.pool.stop()
        taskPool.pool.q.queue = deque()
        DBTestCase.tearDown(self)
 
class TestTasks(TaskTestCase):
   
    @inlineCallbacks
    def testCreateSMS(self):
        with self.session() as session:
            u = User(name='test',apikey='abcdef123456789')
            session.add(u)
        
        job = yield createJob(u,[Telnumber('0123325456')],SMS('sms'),[])
        
        self.assertEqual(taskPool.pool.q.qsize(),1)
        
        self.assertEqual(job.tasks.keys(),[Telnumber('0123325456')])
        self.assertIsInstance(job.tasks[Telnumber('0123325456')], Task)

    @inlineCallbacks
    def testRun(self):
        with self.session() as session:
            u = User(name='test',apikey='abcdef123456789')
            session.add(u)
            o=DBOffer(name="test", provider="bla", route="basic", typ="sms")
            u.rights.append(Userright(o)) 
        
        p=Provider(name="p", typs={"sms":["test",]})
        def send(typ,route,recipient,message):
            return Status(provider=p, route=route)
        p.send=send
        offers["test"] = Offer("test",provider=p, route="test", typ="sms")

        exjob = yield exJobs.create(u, [Telnumber('123456789')], SMS('test'), ['test'])
        
        task=Task(Telnumber('123456789'), exjob)
        task.d=Deferred()
        task._run()
        ret = yield task.d
        self.assertIsInstance(ret, Status)
        self.assertEqual(ret.provider, p)
        self.assertEqual(ret.route, "test")

    def testNoRoute(self):
        with self.session() as session:
            u = User(name='test',apikey='abcdef123456789')
            session.add(u)
        
        def c(exjob):
            task = Task(Telnumber('123456789'), exjob)
            task.d = Deferred()
            task._run()
            self.assertFailure(task.d, NoRouteForTask)
            return task.d

        d = exJobs.create(u, [Telnumber('123456789')], SMS('test'), [])
        d.addCallback(c)
        return d
        
    def testNoRoute2(self):
        with self.session() as session:
            u = User(name='test',apikey='abcdef123456789')
            session.add(u)
            o=DBOffer(name="test", provider="bla", route="basic", typ="sms")
            u.rights.append(Userright(o)) 
            o=DBOffer(name="test2", provider="bla", route="basic2", typ="sms")
            u.rights.append(Userright(o)) 

        p=Provider(name="p", typs={"sms":["basic","basic2"]})
        def send(typ,route,recipient,message):
            raise RejectRecipient(recipient)
        p.send=send
        offers["test"] = Offer("test",provider=p, route="basic", typ="sms")
        offers["test2"] = Offer("test2",provider=p, route="basic2", typ="sms")

        def c(exjob):
            task = Task(Telnumber('123456789'), exjob)
            task.d = Deferred()
            task._run()
            self.assertFailure(task.d, NoRouteForTask)
            return task.d

        d = exJobs.create(u, [Telnumber('123456789')], SMS('test'), ['test','test2'])
        d.addCallback(c)
        return d

    def testChaining(self):
        with self.session() as session:
            u = User(name='test',apikey='abcdef123456789')
            session.add(u)
            o=DBOffer(name="test", provider="bla", route="basic", typ="sms")
            u.rights.append(Userright(o)) 
            o=DBOffer(name="test2", provider="bla", route="basic2", typ="sms")
            u.rights.append(Userright(o)) 

        p=Provider(name="p", typs={"sms":["basic","basic2"]})
        def send(typ,route,recipient,message):
            if route=="basic":
                raise Exception("oh my god an exception")
            return Status(p,route)
        p.send=send
        offers["test"] = Offer("test",provider=p, route="basic", typ="sms")
        offers["test2"] = Offer("test2",provider=p, route="basic2", typ="sms")

        def c(exjob):
            task = Task(Telnumber('123456789'), exjob)
            task.d = Deferred()
            task.d.addCallback(stat, task)
            task._run()
            return task.d
       
        def stat(status, task): 
            errors = self.flushLoggedErrors(Exception)
            self.assertEqual(len(errors), 1)
            self.assertEqual(self.log.e[1]['why'], "Job(%s): Send to '0049123456789' failed via 'test'"% task.job.dbjob)
            self.assertIsInstance(status, Status)
            self.assertEqual(status.provider, p)
            self.assertEqual(status.route, "basic2")

        d = exJobs.create(u, [Telnumber('123456789')], SMS('test'), ['test','test2'])
        d.addCallback(c)
        return d



    def testSetStatus(self):
        task=Task(Telnumber('123456789'), None)
        self.assertEqual(task.status,None)
        self.assertEqual(task.error,False)

        self.assertEqual(task.setStatus("fooja"),"fooja")
        self.assertEqual(task.status,"fooja")

    def testSetError(self):
        task=Task(Telnumber('123456789'), None)
        self.assertEqual(task.setError("fooja"),"fooja")
        self.assertEqual(task.status,"fooja")
        self.assertEqual(task.error,True)