#!/usr/bin/python2.5
#
# Copyright 2009 the Melange authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""GHOP specific views for Programs.
"""

__authors__ = [
    '"Madhusudan.C.S" <madhusudancs@gmail.com>',
    '"Daniel Hans" <daniel.m.hans@gmail.com>',
    '"Lennard de Rijk" <ljvderijk@gmail.com>',
  ]


import datetime
import os

from django import forms
from django import http
from django.utils.translation import ugettext

from soc.logic import cleaning
from soc.logic import dicts
from soc.logic.helper import timeline as timeline_helper
from soc.logic.models import host as host_logic
from soc.views import out_of_band
from soc.views import helper
from soc.views.helper import decorators
from soc.views.helper import dynaform
from soc.views.helper import lists
from soc.views.helper import params as params_helper
from soc.views.helper import redirects
from soc.views.helper import widgets
from soc.views.models import document as document_view
from soc.views.models import program 
from soc.views.sitemap import sidebar

import soc.cache.logic

from soc.modules.ghop.logic.models import mentor as ghop_mentor_logic
from soc.modules.ghop.logic.models import org_admin as ghop_org_admin_logic
from soc.modules.ghop.logic.models import program as ghop_program_logic
from soc.modules.ghop.logic.models import student as ghop_student_logic
from soc.modules.ghop.logic.models import task as ghop_task_logic
from soc.modules.ghop.models import task as ghop_task_model
from soc.modules.ghop.views.helper import access as ghop_access
from soc.modules.ghop.views.helper import redirects as ghop_redirects

import soc.modules.ghop.logic.models.program


class View(program.View):
  """View methods for the GHOP Program model.
  """

  DEF_PARTICIPATING_ORGS_MSG_FMT = ugettext(
      'The following is a list of all the participating organizations under '
      'the programme %(name)s. To know more about each organization and see '
      'the tasks published by them please visit the corresponding links.')

  DEF_TASK_QUOTA_ALLOCATION_MSG = ugettext(
      "Use this view to assign task quotas.")

  DEF_TASK_QUOTA_ERROR_MSG_FMT = ugettext(
      "Task Quota limit for the organizations %s do not contain"
      " a valid number(>0) and has not been updated.")

  def __init__(self, params=None):
    """Defines the fields and methods required for the program View class
    to provide the user with list, public, create, edit and delete views.

    Params:
      params: a dict with params for this View
    """

    rights = ghop_access.GHOPChecker(params)
    rights['show'] = ['allow']
    rights['create'] = [('checkSeeded', ['checkHasActiveRoleForScope',
                                         host_logic.logic])]
    rights['edit'] = [('checkIsHostForProgram', [ghop_program_logic.logic])]
    rights['delete'] = ['checkIsDeveloper']
    rights['accepted_orgs'] = [('checkIsAfterEvent',
        ['student_signup_start',
         '__all__', ghop_program_logic.logic])]
    rights['task_difficulty'] = [('checkIsHostForProgram',
        [ghop_program_logic.logic])]
    rights['task_type'] = [('checkIsHostForProgram',
        [ghop_program_logic.logic])]
    rights['difficulty_tag_edit'] = [('checkIsHostForProgram',
        [ghop_program_logic.logic])]
    rights['type_tag_edit'] = [('checkIsHostForProgram',
        [ghop_program_logic.logic])]

    new_params = {}
    new_params['logic'] = soc.modules.ghop.logic.models.program.logic
    new_params['rights'] = rights

    new_params['name'] = "GHOP Program"
    new_params['module_name'] = "program"
    new_params['sidebar_grouping'] = 'Programs'

    new_params['module_package'] = 'soc.modules.ghop.views.models'
    new_params['url_name'] = 'ghop/program'

    # TODO: this list can be reduced after GSoC has been moved
    new_params['extra_dynaexclude'] = ['min_slots', 'max_slots',
                                       'slot_allocation', 'allocations_visible',
                                       'task_difficulties', 'task_types',
                                       ]

    patterns = []
    patterns += [
        (r'^%(url_name)s/(?P<access_type>assign_task_quotas)/%(key_fields)s$',
          '%(module_package)s.%(module_name)s.assign_task_quotas',
          'Assign task quota limits'),
        (r'^%(url_name)s/(?P<access_type>task_difficulty)/%(key_fields)s$',
         '%(module_package)s.%(module_name)s.task_difficulty_edit',
         'Edit Task Difficulty Tags'),
        (r'^%(url_name)s/(?P<access_type>task_type)/%(key_fields)s$',
         '%(module_package)s.%(module_name)s.task_type_edit',
         'Edit Task Type Tags'),
        (r'^%(url_name)s/(?P<access_type>difficulty_tag_edit)$',
         '%(module_package)s.%(module_name)s.difficulty_tag_edit',
         'Edit a Difficulty Tag'),
        (r'^%(url_name)s/(?P<access_type>type_tag_edit)$',
         '%(module_package)s.%(module_name)s.task_type_tag_edit',
         'Edit a Task Type Tag'),
        ]

    new_params['extra_django_patterns'] = patterns

    params = dicts.merge(params, new_params, sub_merge=True)

    super(View, self).__init__(params=params)

    dynafields = [
        {'name': 'overview_task_difficulties',
         'base': forms.CharField,
         'label': 'Task Difficulty Levels',
         'group': 'Task Settings',
         'widget': widgets.ReadOnlyInput(),
         'required': False,
         'help_text': ugettext('Lists all the difficulty levels that '
                               'can be assigned to a task. Edit them '
                               'from the Program menu on sidebar.'),
         },
         {'name': 'overview_task_types',
         'base': forms.CharField,
         'label': 'Task Type Tags',
         'group': 'Task Settings',
         'widget': widgets.ReadOnlyInput(),
         'required': False,
         'help_text': ugettext('Lists all the types a task can be in. '
                               'Edit them from the Program menu on sidebar.'),
         },
        ]

    dynaproperties = params_helper.getDynaFields(dynafields)

    edit_form = dynaform.extendDynaForm(
        dynaform=self._params['edit_form'],
        dynaproperties=dynaproperties)

    self._params['edit_form'] = edit_form

  def _editGet(self, request, entity, form):
    """See base.View._editGet().
    """

    # TODO: can't a simple join operation do this?
    tds = ghop_task_model.TaskDifficultyTag.get_by_scope(entity)
    if tds:
      td_str = ''
      for td in tds[:-1]:
        td_str += str(td) + ', '

      td_str += str(tds[-1])

      form.fields['overview_task_difficulties'].initial = td_str

    tts = ghop_task_model.TaskTypeTag.get_by_scope(entity)
    if tts:
      tt_str = ''
      for tt in tts[:-1]:
        tt_str += str(tt) + ', '

      tt_str += str(tts[-1])

      form.fields['overview_task_types'].initial = tt_str

    return super(View, self)._editGet(request, entity, form)

  @decorators.merge_params
  @decorators.check_access
  def assignTaskQuotas(self, request, access_type, page_name=None,
                       params=None, filter=None, **kwargs):
    """View that allows to assign task quotas for accepted GHOP organization.

    This view allows the program admin to set the task quota limits
    and change them at any time when the program is active. 
    """

    # TODO: Once GAE Task APIs arrive, this view will be managed by them
    program = ghop_program_logic.logic.getFromKeyFieldsOr404(kwargs)

    from soc.modules.ghop.views.models import \
        organization as ghop_organization_view

    org_params = ghop_organization_view.view.getParams().copy()

    context = {}

    if request.method == 'POST':
      return self.assignTaskQuotasPost(request, context, org_params, 
                                       page_name, params, program,
                                       **kwargs)
    else: # request.method == 'GET'
      return self.assignTaskQuotasGet(request, context, org_params,
                                      page_name, params, program, 
                                      **kwargs)

  def assignTaskQuotasPost(self, request, context, org_params, 
                           page_name, params, entity, **kwargs):
    """Handles the POST request for the task quota allocation page.

    Args:
        entity: the program entity
        rest: see base.View.public()
    """

    ghop_org_logic = org_params['logic']

    error_orgs = ''
    for link_id, task_count in request.POST.items():
      fields = {
          'link_id': link_id,
          'scope': entity,
          'scope_path': entity.key().id_or_name(),
          }
      key_name = ghop_org_logic.getKeyNameFromFields(fields)

      try:
        task_count = int(task_count)
        if task_count >= 0:
          fields['task_quota_limit'] = task_count
          ghop_org_logic.updateOrCreateFromKeyName(fields, key_name)
        else:
          raise ValueError
      except ValueError:
        org_entity = ghop_org_logic.getFromKeyName(key_name)
        error_orgs += org_entity.name + ', ' 

    if error_orgs:
      context['error_message'] = self.DEF_TASK_QUOTA_ERROR_MSG_FMT % (
          error_orgs[:-2])    

      return self.assignTaskQuotasGet(request, context, org_params,
                                      page_name, params, entity,
                                      **kwargs) 

    # redirect to the same page
    return http.HttpResponseRedirect('')

  def assignTaskQuotasGet(self, request, context, org_params, 
                          page_name, params, entity, **kwargs):
    """Handles the GET request for the task quota allocation page.

    Args:
        entity: the program entity
        rest see base.View.public()
    """

    org_params['list_template'] = ('modules/ghop/program/'
        'allocation/allocation.html')
    org_params['list_heading'] = ('modules/ghop/program/'
        'allocation/heading.html')
    org_params['list_row'] = 'modules/ghop/program/allocation/row.html'
    org_params['list_pagination'] = 'soc/list/no_pagination.html'

    description = self.DEF_TASK_QUOTA_ALLOCATION_MSG

    filter = {
        'scope': entity,
        'status': 'active',
        }

    content = self._getAcceptedOrgsList(description, org_params,
                                        filter, False)

    contents = [content]

    return self._list(request, org_params, contents, page_name, context)

  @decorators.merge_params
  def getExtraMenus(self, id, user, params=None):
    """See soc.views.models.program.View.getExtraMenus().
    """

    logic = params['logic']
    rights = params['rights']

    # only get all invisible and visible programs
    fields = {'status': ['invisible', 'visible']}
    entities = logic.getForFields(fields)

    menus = []

    rights.setCurrentUser(id, user)

    for entity in entities:
      items = []

      if entity.status == 'visible':
        # show the documents for this program, even for not logged in users
        items += document_view.view.getMenusForScope(entity, params)
        items += self._getTimeDependentEntries(entity, params, id, user)

      try:
        # check if the current user is a host for this program
        rights.doCachedCheck('checkIsHostForProgram',
                             {'scope_path': entity.scope_path,
                              'link_id': entity.link_id}, [])

        if entity.status == 'invisible':
          # still add the document links so hosts can see how it looks like
          items += document_view.view.getMenusForScope(entity, params)
          items += self._getTimeDependentEntries(entity, params, id, user)

        items += [(redirects.getReviewOverviewRedirect(
            entity, {'url_name': 'ghop/org_app', 'scope_view': self}),
            "Review Organization Applications", 'any_access')]
        # add link to edit Program Profile
        items += [(redirects.getEditRedirect(entity, params),
            'Edit Program Profile', 'any_access')]
        # add link to Assign Task Quota limits
        items += [(ghop_redirects.getAssignTaskQuotasRedirect(entity, params),
            'Assign Task Quota limits', 'any_access')]
        # add link to edit Program Timeline
        items += [(redirects.getEditRedirect(
            entity, {'url_name': 'ghop/timeline'}),
            "Edit Program Timeline", 'any_access')]
        # add link to create a new Program Document
        items += [(redirects.getCreateDocumentRedirect(entity, 'ghop/program'),
            "Create a New Document", 'any_access')]
        # add link to list all Program Document
        items += [(redirects.getListDocumentsRedirect(entity, 'ghop/program'),
            "List Documents", 'any_access')]
        # add link to edit Task Difficulty Levels
        items += [(ghop_redirects.getDifficultyEditRedirect(
            entity, {'url_name': 'ghop/program'}),
            "Edit Task Difficulty Levels", 'any_access')]
        # add link to edit Task Type Tags
        items += [(ghop_redirects.getTaskTypeEditRedirect(
            entity, {'url_name': 'ghop/program'}),
            "Edit Task Type Tags", 'any_access')]

      except out_of_band.Error:
        pass

      items = sidebar.getSidebarMenu(id, user, items, params=params)
      if not items:
        continue

      menu = {}
      menu['heading'] = entity.short_name
      menu['items'] = items
      menu['group'] = 'Programs'
      menus.append(menu)
    
    return menus

  def _getTimeDependentEntries(self, ghop_program_entity, params, id, user):
    """Returns a list with time dependent menu items.
    """

    items = []

    timeline_entity = ghop_program_entity.timeline

    # get the student entity for this user and program
    filter = {'user': user,
              'scope': ghop_program_entity,
              'status': 'active'}
    student_entity = ghop_student_logic.logic.getForFields(filter, unique=True)

    if student_entity:
      items += self._getStudentEntries(ghop_program_entity, student_entity,
                                       params, id, user)
    else:  
      # if a user has a task assigned, he or she still may list it
      filter = {
          'user': user,
          'program': ghop_program_entity,
          'status': ['ClaimRequested', 'Claimed', 'ActionNeeded', 'NeedsWork',
              'AwaitingRegistration', 'NeedsReview'] 
          }
      tasks = ghop_task_logic.logic.getForFields(filter)

      if tasks:
        items += [(ghop_redirects.getListStudentTasksRedirect(
            ghop_program_entity, {'url_name':'ghop/student'}),
            "List my Tasks", 'any_access')]

    # get mentor and org_admin entity for this user and program
    filter = {'user': user,
              'program': ghop_program_entity,
              'status': 'active'}
    mentor_entity = ghop_mentor_logic.logic.getForFields(filter, unique=True)
    org_admin_entity = ghop_org_admin_logic.logic.getForFields(
        filter, unique=True)

    if mentor_entity or org_admin_entity:
      items += self._getOrganizationEntries(
          ghop_program_entity, org_admin_entity,
          mentor_entity, params, id, user)

    if user and not (student_entity or mentor_entity or org_admin_entity):
      if timeline_helper.isActivePeriod(timeline_entity, 'student_signup'):
        # this user does not have a role yet for this program
        items += [('/ghop/student/apply/%s' % (
            ghop_program_entity.key().id_or_name()),
            "Register as a Student", 'any_access')]

    if timeline_helper.isAfterEvent(timeline_entity, 'org_signup_start'):
      url = redirects.getAcceptedOrgsRedirect(
          ghop_program_entity, params)
      # add a link to list all the organizations
      items += [(url, "List participating Organizations", 'any_access')]

    return items

  def _getStudentEntries(self, ghop_program_entity, student_entity, 
                         params, id, user):
    """Returns a list with menu items for students in a specific program.
    """

    items = []

    timeline_entity = ghop_program_entity.timeline

    if timeline_helper.isAfterEvent(timeline_entity,
                                   'student_signup_start'):
      # add a link to show all projects
      items += [(ghop_redirects.getListStudentTasksRedirect(
          ghop_program_entity, {'url_name':'ghop/student'}),
          "List my Tasks", 'any_access')]

    items += [(redirects.getEditRedirect(student_entity, 
        {'url_name': 'ghop/student'}),
        "Edit my Student Profile", 'any_access')]

    items += [(redirects.getManageRedirect(student_entity,
        {'url_name':'ghop/student'}),
        "Resign as a Student", 'any_access')]

    return items

  @decorators.merge_params
  @decorators.check_access
  def taskDifficultyEdit(self, request, access_type, page_name=None,
                         params=None, filter=None, **kwargs):
    """View method used to edit Difficulty Level tags.
    """

    params = dicts.merge(params, self._params)

    try:
      entity = self._logic.getFromKeyFieldsOr404(kwargs)
    except out_of_band.Error, error:
      return helper.responses.errorResponse(
          error, request, template=params['error_public'])

    context = helper.responses.getUniversalContext(request)
    helper.responses.useJavaScript(context, params['js_uses_all'])
    context['page_name'] = page_name

    context['program_key_name'] = entity.key().name()

    context['difficulties'] = ghop_task_model.TaskDifficultyTag.get_by_scope(
        entity)

    params['edit_template'] = 'modules/ghop/program/tag/difficulty.html'

    return self._constructResponse(request, entity, context, None, params)

  @decorators.merge_params
  @decorators.check_access
  def difficultyTagEdit(self, request, access_type, page_name=None,
                        params=None, filter=None, **kwargs):
    """View method used to edit a supplied Difficulty level tag.
    """

    get_params = request.GET

    order = get_params.getlist('order')
    program_key_name = get_params.get('program_key_name')

    program_entity = ghop_program_logic.logic.getFromKeyName(
        program_key_name)

    if order:
      for index, elem in enumerate(order):
        ghop_task_model.TaskDifficultyTag.update_order(
              program_entity, elem, index)
      return http.HttpResponse()
    else:
      tag_data = get_params.getlist('tag_data')

      tag_name = tag_data[0].strip()
      tag_value = tag_data[1].strip()

      if tag_name:
        if not tag_value:
          ghop_task_model.TaskDifficultyTag.delete_tag(
              program_entity, tag_name)
        elif tag_name != tag_value:
          ghop_task_model.TaskDifficultyTag.copy_tag(
              program_entity, tag_name, tag_value)
      else:
        ghop_task_model.TaskDifficultyTag.get_or_create(
            program_entity, tag_value)

      return http.HttpResponse(tag_value)

  @decorators.merge_params
  @decorators.check_access
  def taskTypeEdit(self, request, access_type, page_name=None,
                   params=None, filter=None, **kwargs):
    """View method used to edit Task Type tags.
    """

    params = dicts.merge(params, self._params)

    try:
      entity = self._logic.getFromKeyFieldsOr404(kwargs)
    except out_of_band.Error, error:
      return helper.responses.errorResponse(
          error, request, template=params['error_public'])

    context = helper.responses.getUniversalContext(request)
    helper.responses.useJavaScript(context, params['js_uses_all'])
    context['page_name'] = page_name

    context['program_key_name'] = entity.key().name()

    context['task_types'] = ghop_task_model.TaskTypeTag.get_by_scope(
        entity)

    params['edit_template'] = 'modules/ghop/program/tag/task_type.html'

    return self._constructResponse(request, entity, context, None, params)

  @decorators.merge_params
  @decorators.check_access
  def taskTypeTagEdit(self, request, access_type, page_name=None,
                      params=None, filter=None, **kwargs):
    """View method used to edit a supplied Task Type tag.
    """

    get_params = request.GET

    order = get_params.getlist('order')
    program_key_name = get_params.get('program_key_name')

    program_entity = ghop_program_logic.logic.getFromKeyName(
        program_key_name)

    if order:
      for index, elem in enumerate(order):
        ghop_task_model.TaskTypeTag.update_order(
              program_entity, elem, index)
      return http.HttpResponse()
    else:
      tag_data = get_params.getlist('tag_data')
      program_key_name = get_params.get('program_key_name')

      tag_name = tag_data[0].strip()
      tag_value = tag_data[1].strip()

      program_entity = ghop_program_logic.logic.getFromKeyName(
          program_key_name)

      if tag_name:
        if not tag_value:
          ghop_task_model.TaskTypeTag.delete_tag(
              program_entity, tag_name)
        elif tag_name != tag_value:
          ghop_task_model.TaskTypeTag.copy_tag(
              program_entity, tag_name, tag_value)
      else:
        ghop_task_model.TaskTypeTag.get_or_create(program_entity, tag_value)

      return http.HttpResponse(tag_value)

  @decorators.merge_params
  @decorators.check_access
  def acceptedOrgs(self, request, access_type,
                   page_name=None, params=None, filter=None, **kwargs):
    """List all the accepted orgs for the given program.
    """

    from soc.modules.ghop.views.models.organization import view as \
        ghop_org_view

    contents = []
    logic = params['logic']

    ghop_program_entity = logic.getFromKeyFieldsOr404(kwargs)

    ao_params = ghop_org_view.getParams().copy()
    ao_params['list_action'] = (redirects.getHomeRedirect,
                                ao_params)
    ao_params['list_description'] = self.DEF_PARTICIPATING_ORGS_MSG_FMT % {
        'name': ghop_program_entity.name
        }

    filter = {
        'scope': ghop_program_entity,
        'status': ['new', 'active'],
        }

    order = ['name']

    ao_list = lists.getListContent(request, ao_params, filter=filter,
                                   order=order, idx=0)

    contents.append(ao_list)

    params = params.copy()
    params['list_msg'] = ghop_program_entity.accepted_orgs_msg

    return self._list(request, params, contents, page_name)


view = View()

admin = decorators.view(view.admin)
accepted_orgs = decorators.view(view.acceptedOrgs)
assign_task_quotas = decorators.view(view.assignTaskQuotas)
create = decorators.view(view.create)
delete = decorators.view(view.delete)
edit = decorators.view(view.edit)
list = decorators.view(view.list)
public = decorators.view(view.public)
export = decorators.view(view.export)
home = decorators.view(view.home)
difficulty_tag_edit = decorators.view(view.difficultyTagEdit)
task_type_tag_edit = decorators.view(view.taskTypeTagEdit)
task_difficulty_edit = decorators.view(view.taskDifficultyEdit)
task_type_edit = decorators.view(view.taskTypeEdit)
