#!/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.

"""Custom widgets used for Survey form fields, plus the SurveyContent form.

"""

__authors__ = [

  '"Daniel Diniz" <ajaksu@gmail.com>',

  '"James Levy" <jamesalexanderlevy@gmail.com>',

  '"Lennard de Rijk" <ljvderijk@gmail.com>',

  ]

from itertools import chain

import csv

import datetime

import logging

import StringIO

from google.appengine.ext import db

from google.appengine.ext.db import djangoforms

from django import forms

from django.forms import widgets

from django.forms.fields import CharField

from django.template import loader

from django.utils.datastructures import SortedDict

from django.utils.encoding import force_unicode

from django.utils.html import escape

from django.utils.safestring import mark_safe

from soc.logic import dicts

from soc.logic.lists import Lists

from soc.models.survey import COMMENT_PREFIX

from soc.models.survey import SurveyContent

CHOICE_TYPES = set(('selection', 'pick_multi', 'choice', 'pick_quant'))

# TODO(ajaksu) add this to template

REQUIRED_COMMENT_TPL = """

  <label for="required_for_{{ name }}">Required</label>

  <select id="required_for_{{ name }}" name="required_for_{{ name }}">

    <option value="True" {% if is_required %} selected='selected' {% endif %}

     >True</option>

    <option value="False" {% if not is_required %} selected='selected'

     {% endif %}>False</option>

  </select>

  <label for="comment_for_{{ name }}">Allow Comments</label>

  <select id="comment_for_{{ name }}" name="comment_for_{{ name }}">

    <option value="True" {% if has_comment %} selected='selected' {% endif %}

     >True</option>

    <option value="False" {% if not has_comment %} selected='selected'

     {% endif %}>False</option>

  </select>

"""

class SurveyTakeForm(djangoforms.ModelForm):

  """SurveyContent form for recording survey answers.

  This class is used to produce survey forms for survey taking:

    - User taking survey

    - User updating already taken survey

  Using dynamic properties of the survey model (if passed as an arg) the

  survey form is dynamically formed.

  """

  def __init__(self, *args, **kwargs):

    """Store special kwargs as attributes.

    params:

      survey_content: a SuveryContent entity.

      survey_logic: instance of SurveyLogic.

      survey_record: a SurveyRecord entity.

      read_only: controls whether the survey taking UI allows data entry.

      data: dictionary mapping fields to data for validation.

    """

    self.kwargs = kwargs

    self.survey_content = self.kwargs.pop('survey_content', None)

    self.survey_logic = self.kwargs.pop('survey_logic', None)

    self.survey_record = self.kwargs.pop('survey_record', None)

    self.read_only = self.kwargs.pop('read_only', None)

    self.fields_map = dict(

        long_answer=self.addLongField,

        short_answer=self.addShortField,

        selection=self.addSingleField,

        pick_multi=self.addMultiField,

        pick_quant=self.addQuantField,

        )

    # get the POST data dict if present

    data = self.kwargs.pop('data', None)

    # set cleaner methods for fields, only needed if we have POST data

    if data:

      # prepare to render a bound, validating form

      clean_data = self.setCleaners(data)

    else:

      clean_data = self.setCleaners()

    # update with fields from subclasses

    if hasattr(self, 'data') and self.data:

        clean_data.update(self.data)

        delattr(self, 'data')

    # pass data, so form is bound

    if data:

      self.kwargs['data'] = clean_data

    super(SurveyTakeForm, self).__init__(*args, **self.kwargs)

    self.fields = self.getFields(clean_data)

  def setCleaners(self, post_dict=None):

    """Set cleaner methods for dynamic fields.

    Used for storing textual input as Text instead of StringProperty. If

    passed a dict of field names/values (as the kwarg 'data' to __init__),

    it's possible to set clean_[field_id] methods for validation.

    This method populates the 'data' dict used for generating form fields.

    Args:

      post_dict: dictionary used to populate the fields

    """

    # prefix for method names

    clean = 'clean_'

    # data is passed to super's __init__ as the 'data' kwarg

    data = {}

    # flag whether we can use getlist to retrieve multiple values

    is_post = hasattr(post_dict, 'getlist')

    schema = {}

    if self.survey_content:

      schema = eval(self.survey_content.schema)

    for key, val in schema.items():

      if val['type'] == 'long_answer':

        # store > 500 chars per long answer

        setattr(self, clean + key,

                lambda key=key: db.Text(self.cleaned_data.get(key))

                )

      if val['has_comment']:

        comment = COMMENT_PREFIX + key

        #store > 500 chars per comment field

        setattr(self, clean + comment,

                lambda comment=comment: db.Text(self.cleaned_data.get(comment))

                )

        # put comment in self.data

        if post_dict:

          comment_val = post_dict.get(comment) or None

        else:

          comment_val = getattr(self.survey_record, comment, None)

        data[comment] = comment_val

      # put POST or record value for field in self.data

      is_multi = val['type'] == 'pick_multi'

      if post_dict:

        if is_multi and is_post:

          key_val = post_dict.getlist(key)

        else:

          key_val = post_dict.get(key)

      else:

        key_val = getattr(self.survey_record, key, None)

        if is_multi and isinstance(key_val, basestring):

          # TODO(ajaksu): find out if we still need this safety net

          key_val = key_val.split(',')

        elif not is_multi and isinstance(key_val, list):

          # old pick_multi record for a question that is now single choice

          key_val = key_val[0] if key_val else ''

      data[key] = key_val

    return data

  def getFields(self, post_dict=None):

    """Build the SurveyContent (questions) form fields.

    params:

      post_dict: dict with POST data that will be used for validation

    Populates self.survey_fields, which will be ordered in self.insertFields.

    """

    if not self.survey_content:

      return

    post_dict = post_dict or {}

    self.survey_fields = {}

    schema = SurveyContentSchema(self.survey_content.schema)

    attrs = {}

    # figure out whether we want a read-only view

    read_only = self.read_only

    if not read_only:

      survey_content = self.survey_content

      survey_entity = self.survey_logic.getSurveyForContent(survey_content)

      deadline = survey_entity.survey_end

      read_only = deadline and (datetime.datetime.now() > deadline)

    if read_only:

      attrs['disabled'] = 'disabled'

    # add unordered fields to self.survey_fields

    for field in self.survey_content.dynamic_properties():

      value = post_dict.get(field)

      # skip comments, as they should go below their corresponding questions

      if field.startswith(COMMENT_PREFIX):

        continue

      label = schema.getLabel(field)

      if label is None:

        # we log this error in getLabel

        continue

      # find correct field type

      addField = self.fields_map[schema.getType(field)]

      # check if question is required, it's never required when editing

      required = schema.getRequired(field)

      tip = schema.getTip(field)

      kwargs = dict(label=label, req=required, tip=tip)

      # copy attrs

      extra_attrs = attrs.copy()

      # add new field

      addField(field, value, extra_attrs, schema, **kwargs)

      # handle comments if question allows them

      if schema.getHasComment(field):

        comment = post_dict.get(COMMENT_PREFIX + field)

        self.addCommentField(field, comment, extra_attrs, tip='Add a comment.')

    return self.insertFields()

  def insertFields(self):

    """Add ordered fields to self.fields.

    """

    fields = SortedDict()

    survey_order = self.survey_content.getSurveyOrder()

    # first, insert dynamic survey fields

    for position, property in sorted(survey_order.items()):

      fields.insert(len(fields) + 1, property, self.survey_fields[property])

      # add comment if field has one and this isn't an edit view

      property = COMMENT_PREFIX + property

      if property in self.survey_fields:

        fields.insert(len(fields) + 1, property, self.survey_fields[property])

    return fields

  def addLongField(self, field, value, attrs, schema, req=True, label='',

                   tip='', comment=''):

    """Add a long answer fields to this form.

    params:

      field: the current field

      value: the initial value for this field

      attrs: additional attributes for field

      schema: schema for survey

      req: required bool

      label: label for field

      tip: tooltip text for field

      comment: initial comment value for field

    """

    widget = widgets.Textarea(attrs=attrs)

    if not tip:

      tip = 'Please provide a long answer to this question.'

    question = CharField(help_text=tip, required=req, label=label,

                         widget=widget, initial=value)

    self.survey_fields[field] = question

  def addShortField(self, field, value, attrs, schema, req=False, label='',

                    tip='', comment=''):

    """Add a short answer fields to this form.

    params:

      field: the current field

      value: the initial value for this field

      attrs: additional attributes for field

      schema: schema for survey

      req: required bool

      label: label for field

      tip: tooltip text for field

      comment: initial comment value for field

    """

    attrs['class'] = "text_question"

    widget = widgets.TextInput(attrs=attrs)

    if not tip:

      tip = 'Please provide a short answer to this question.'

    question = CharField(help_text=tip, required=req, label=label,

                         widget=widget, max_length=140, initial=value)

    self.survey_fields[field] = question

  def addSingleField(self, field, value, attrs, schema, req=False, label='',

                     tip='', comment=''):

    """Add a selection field to this form.

    params:

      field: the current field

      value: the initial value for this field

      attrs: additional attributes for field

      schema: schema for survey

      req: required bool

      label: label for field

      tip: tooltip text for field

      comment: initial comment value for field

    """

    widget = PickOneSelect(attrs)

    these_choices = []

    # add all properties, but select chosen one

    # TODO(ajaksu): this breaks ordering and blocks merging choice methods

    options = getattr(self.survey_content, field)

    if self.survey_record and hasattr(self.survey_record, field):

      these_choices.append((value, value))

      if value in options:

        options.remove(value)

    for option in options:

      these_choices.append((option, option))

    if not tip:

      tip = 'Please select an answer this question.'

    question = PickOneField(help_text=tip, required=req, label=label,

                            choices=tuple(these_choices), widget=widget)

    self.survey_fields[field] = question

  def addMultiField(self, field, value, attrs, schema, req=False, label='',

                    tip='', comment=''):

    """Add a pick_multi field to this form.

    params:

      field: the current field

      value: the initial value for this field

      attrs: additional attributes for field

      schema: schema for survey

      req: required bool

      label: label for field

      tip: tooltip text for field

      comment: initial comment value for field

    """

    widget = PickManyCheckbox(attrs)

    # TODO(ajaksu) need to allow checking checkboxes by default

    if self.survey_record and isinstance(value, basestring):

      # pass value as 'initial' so MultipleChoiceField renders checked boxes

      value = value.split(',')

    these_choices = [(v,v) for v in getattr(self.survey_content, field)]

    if not tip:

      tip = 'Please select one or more of these choices.'

    question = PickManyField(help_text=tip, required=req, label=label,

                             choices=tuple(these_choices), widget=widget,

                             initial=value)

    self.survey_fields[field] = question

  def addQuantField(self, field, value, attrs, schema, req=False, label='',

                    tip='', comment=''):

    """Add a pick_quant field to this form.

    params:

      field: the current field

      value: the initial value for this field

      attrs: additional attributes for field

      schema: schema for survey

      req: required bool

      label: label for field

      tip: tooltip text for field

      comment: initial comment value for field

    """

    widget = PickQuantRadio(attrs)

    if self.survey_record:

      value = value

    else:

      value = None

    these_choices = [(v,v) for v in getattr(self.survey_content, field)]

    if not tip:

      tip = 'Please select one of these choices.'

    question = PickQuantField(help_text=tip, required=req, label=label,

                             choices=tuple(these_choices), widget=widget,

                             initial=value)

    self.survey_fields[field] = question

  def addCommentField(self, field, comment, attrs, tip):

    """Add comment field to a question.

    params:

      field: the name of the field to add the comment field to

      comment: the initial value of this field.

      attrs: the attrs for the widget

      tip: tooltip text for this field

    """

    attrs['class'] = 'comment'

    attrs['rows'] = '1'

    widget = widgets.Textarea(attrs=attrs)

    comment_field = CharField(help_text=tip, required=False,

        label='Add a Comment (optional)', widget=widget, initial=comment)

    self.survey_fields[COMMENT_PREFIX + field] = comment_field

  class Meta(object):

    model = SurveyContent

    exclude = ['schema']

class SurveyEditForm(djangoforms.ModelForm):

  """SurveyContent form for editing a survey.

  This class is used to produce survey forms for several circumstances:

    - Admin creating survey from scratch

    - Admin updating existing survey

  Using dynamic properties of the survey model (if passed as an arg) the

  survey form is dynamically formed.

  """

  def __init__(self, *args, **kwargs):

    """Store special kwargs as attributes.

    params:

      survey_content: a SurveyContent entity.

      survey_logic: an instance of SurveyLogic.

    """

    self.kwargs = kwargs

    self.survey_content = self.kwargs.pop('survey_content', None)

    self.survey_logic = self.kwargs.pop('survey_logic', None)

    super(SurveyEditForm, self).__init__(*args, **self.kwargs)

  def getFields(self):

    """Build the SurveyContent (questions) form fields.

    params:

      post_dict: dict with POST data that will be used for validation

    Populates self.survey_fields, which will be ordered in self.insert_fields.

    Also populates self.data, which will be used in form validation.

    """

    if not self.survey_content:

      return

    self.survey_fields = {}

    schema = SurveyContentSchema(self.survey_content.schema)

    extra_attrs = {}