# cc2 <http://cc2.berlios.de/> is a web application to drive
# grassroot initiatives.
#
# Copyright (C) 2009 Alberto Granzotto <agranzot@gmail.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import turbogears as tg
from turbogears import controllers, expose, flash, validators
from turbogears import identity, redirect, validate, error_handler
from turbogears.database import session
from cherrypy import request, response
from cc2.utils import *
from cc2.model import *
from forms import *
from data_grids import *
from cc2.widgets import *
from cc2.other_validators import *

class PoliticianController(controllers.Controller):
    @expose('cc2.templates.error')
    def error(self, tg_errors=None):
        return dict(error_message=tg_errors)

    @expose('cc2.templates.manage.genericform')
    @error_handler(error)
    @validate(validators={'id': CheckExistance(query=Party.query.get)})
    @identity.require(identity.has_permission('create_politician'))
    def create(self, id):
        return dict(
                title=_('Create a new Politician'), form=politician_form,
                submit_text=_('save'), action='../do_create/%s'%id, values=None)

    @expose()
    @error_handler(create)
    @identity.require(identity.has_permission('create_politician'))
    @validate(form=politician_form,
        validators={'id': CheckExistance(query=Party.query.get)})
    def do_create(self, id, **kw):
        o = Politician()
        o.name = kw['name']
        o.surname = kw['surname']
        o.birthdate = kw['birthdate']
        o.phone_number = kw['phone_number']
        o.email = kw['email']
        o.site = kw['site']
        o.party = Party.query.get(id)
        session.save(o)
        session.flush()

        if kw['avatar'].filename:
            f = kw['avatar'].file
        else:
            f = file(tg.config.get('avatar.unknown.politician'))
        resize_image(f, o.id, tg.config.get('avatar.upload.politicians'))

        session.save(Actionlog(
            user_id=identity.current.user_id,
            action='C',
            description='politician create',
            model_name=Politician.__name__,
            object_id=o.id)
        )
        session.flush()
        flash(_('You have created %s %s') % (o.name, o.surname))
        raise redirect('/party/details/%s'%id)

    @expose('cc2.templates.manage.genericform')
    @error_handler(error)
    @validate(validators={'id': CheckExistance(query=Politician.query.get)})
    @identity.require(is_mine_or_group(Politician, 'id'))
    def update(self, id):
        values = Foo(Politician.query().get(id))
        if values.birthdate:
            values.birthdate = values.birthdate.strftime('%d/%m/%Y')
        return dict(
                title=_('Update Politician'), form=update_politician_form,
                submit_text=_('update'), action='../do_update/%s' % id,
                values=values)

    @expose()
    @error_handler(update)
    @validate(validators={'id': CheckExistance(query=Politician.query.get)},
        form=update_politician_form)
    @identity.require(is_mine_or_group(Politician, 'id'))
    def do_update(self, id, **kw):
        o = Politician.query().get(id)
        o.name = kw['name']
        o.surname = kw['surname']
        o.birthdate = kw['birthdate']
        o.phone_number = kw['phone_number']
        o.email = kw['email']
        o.site = kw['site']
        o.party = Party.query.get(kw['party_id'])

        if kw['avatar'].filename:
            f = kw['avatar'].file
            resize_image(f, id, tg.config.get('avatar.upload.politicians'))

        session.flush()
        session.save(Actionlog(
            user_id=identity.current.user_id,
            action='U',
            description='politician update',
            model_name=Politician.__name__,
            object_id=o.id)
        )
        session.flush()
        flash(_('You have updated %s %s') % (o.name, o.surname))
        raise redirect('/politician/details/%s'%id)

    @expose('cc2.templates.manage.genericdelete')
    @error_handler(error)
    @validate(validators={'id': CheckExistance(query=Politician.query.get)})
    @identity.require(is_mine_or_group(Politician, 'id'))
    def delete(self, id, **kw):
        o = Politician.query().get(id)
        what = []
        what.append( (
            _('candidancies in:'),
            [c.election.long_name for c in o.candidancies])
        )
        return dict(title=_('Delete Politician'),
            what=what,
            go_back='/politician/details/%s'%id,
            go_on='/politician/do_delete/%s'%id)

    @expose()
    @error_handler(error)
    @validate(validators={'id': CheckExistance(query=Politician.query.get)})
    @identity.require(is_mine_or_group(Politician, 'id'))
    def do_delete(self, id, **kw):
        o = Politician.query().get(id)

        session.delete(o)
        session.save(Actionlog(
            user_id=identity.current.user_id,
            action='D',
            description='politician delete',
            model_name=Politician.__name__,
            object_id=o.id)
        )
        session.flush()
        flash(_('You have deleted %s %s') % (o.name, o.surname))
        raise redirect("/")

    #FIXME: this is totally wrong
    @expose('cc2.templates.manage.genericgrid')
    @identity.require(identity.has_permission('retrieve_politician'))
    def list(self):
        data = Politician.query().all()
        return dict(title=_('Politician List'), grid=politician_list, data=data)

    @expose('cc2.templates.politician.details')
    @error_handler(error)
    @validate(validators={'id': CheckExistance(query=Politician.query.get)})
    def details(self, id):
        #TODO: eager load all
        politician = Politician.query().get(id)
        # all in one query \m/
        query_select = [election_table.c.id,
                        election_type_table.c.name,
                        place_table.c.name,
                        election_table.c.start,
                        election_table.c.end,
                        district_table.c.name,
                        electoral_roll_table.c.id,
                        electoral_roll_table.c.position,
                        candidate_table.c.id,
                        candidate_table.c.elected,
                        candidate_table.c.agrees]
        query_from = [politician_table.join(candidate_table)\
                              .join(party_table, onclause=politician_table.c.party_id==party_table.c.id)\
                              .join(election_table).join(electoral_roll_table)\
                              .join(election_type_table).join(place_table)]
        query_where = (politician_table.c.id == id) & (electoral_roll_table.c.district_id==district_table.c.id)
        super_query = select(query_select, from_obj=query_from, whereclause=query_where).order_by(party_table.c.id)
        rs = session.execute(super_query)

        last_election_id = None
        elections = []
        current_election = None
        for r in rs:
            election_id, election_type, place_name, election_start, election_end, district_name, electoral_roll_id, electoral_position, candidate_id, elected, agrees = r
            if last_election_id != election_id:
                begin = str(election_start.day)
                end = tg.i18n.format.format_date(election_end, format='long')
                if end.startswith('0'):
                    end = end[1:]
                interval = '%s-%s' % (begin, end)
                if end.startswith(begin + ' '):
                    interval = end

                current_election = Foo(
                    id = election_id,
                    type= election_type,
                    place = place_name,
                    interval = interval,
                    candidate_id = candidate_id,
                    candidancies=[])
                elections.append(current_election)
                last_election_id = election_id

            current_election.candidancies.append(Foo(name=district_name, electoral_roll_id=electoral_roll_id, position=electoral_position, elected=elected, agrees=agrees))
        if politician.birthdate:
            politician.pretty_birthdate = tg.i18n.format.format_date(politician.birthdate, format='short')
        else:
            politician.pretty_birthdate = ''
        return dict(politician=politician, elections=elections)

    @expose()
    def antani(self, tg_errors=None):
        return dict(matches=['error'])

    @expose(format='json')
    @error_handler(antani)
    @validate(validators={'politician': validators.UnicodeString()})
    def search(self, politician):
        politician = politician.lower()
        rs = Politician.query.filter(
            Politician.name.like('%'+politician+'%') | Politician.surname.like('%'+politician+'%')
        ).order_by(Politician.name)[0:10]
        matches = ['%s, %s' % (r.full_name, r.party.name) for r in rs]
        return dict(matches=matches)