################################################################################
#
# Copyright (c) 2002-2005, Benjamin Saller <bcsaller@ideasuite.com>, and
#                              the respective authors. All rights reserved.
# For a list of Archetypes contributors see docs/CREDITS.txt.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
# * Neither the name of the author nor the names of its contributors may be used
#   to endorse or promote products derived from this software without specific
#   prior written permission.
#
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
################################################################################

from unittest import TestSuite, makeSuite

import os
import PIL

from zope.annotation.interfaces import IAttributeAnnotatable
from zope.interface import implements, alsoProvides
from zope.component import getSiteManager
from zope.publisher.browser import TestRequest
from zope.schema.interfaces import IVocabularyFactory
from zope.schema.vocabulary import SimpleVocabulary

from Products.Archetypes.tests.atsitetestcase import ATSiteTestCase
from Products.Archetypes.tests.atsitetestcase import portal_name
from Products.Archetypes.tests.utils import mkDummyInContext
from Products.Archetypes.tests.utils import PACKAGE_HOME

from Products.Archetypes.atapi import Schema, DisplayList, IntDisplayList, BaseContentMixin, TextField
from Products.Archetypes.interfaces import IFieldDefaultProvider
from Products.Archetypes.interfaces.vocabulary import IVocabulary
from Products.Archetypes import Field as at_field
from Products import PortalTransforms
from OFS.Image import File, Image
from DateTime import DateTime


test_fields = [
    ('ObjectField', 'objectfield'),
    ('StringField', 'stringfield'),
    ('FileField', 'filefield'),
    ('TextField', 'textfield'),
    ('DateTimeField', 'datetimefield'),
    ('LinesField', 'linesfield'),
    ('IntegerField', 'integerfield'),
    ('FloatField', 'floatfield'),
    ('FloatField', 'floatfield2'),
    ('FixedPointField', 'fixedpointfield1'),
    ('FixedPointField', 'fixedpointfield2'),
    ('BooleanField', 'booleanfield'),
    ('ImageField', 'imagefield'),
    ]

field_instances = []
for type, name in test_fields:
    field_instances.append(getattr(at_field, type)(name))

txt_file = open(os.path.join(PACKAGE_HOME, 'input', 'rest1.rst'))
txt_content = txt_file.read()
img_file = open(os.path.join(PACKAGE_HOME, 'input', 'tool.gif'), 'rb')
img_content = img_file.read()
animated_gif_file = open(os.path.join(PACKAGE_HOME, 'input', 'animated.gif'), 'rb')
animated_gif_content = animated_gif_file.read()
pdf_file = open(os.path.join(PACKAGE_HOME, 'input', 'webdav.pdf'), 'rb')
pdf_content = pdf_file.read()

field_values = {
    'objectfield': 'objectfield',
    'stringfield': 'stringfield',
    'filefield_file': txt_file,
    'textfield': 'textfield',
    'datetimefield': '',
    'datetimefield_year': '2003',
    'datetimefield_month': '01',
    'datetimefield_day': '01',
    'datetimefield_hour': '03',
    'datetimefield_minute': '04',
    'linesfield': 'bla\nbla',
    'integerfield': '1',
    'floatfield': '1.5',
    'floatfield2': '1,2',
    'fixedpointfield1': '1.5',
    'fixedpointfield2': '1,5',
    'booleanfield': '1',
    'imagefield_file': img_file,
    }

expected_values = {
    'objectfield': 'objectfield',
    'stringfield': 'stringfield',
    'filefield': txt_content,
    'textfield': 'textfield',
    'datetimefield': DateTime(2003, 01, 01, 03, 04),
    'linesfield': ('bla', 'bla'),
    'integerfield': 1,
    'floatfield': 1.5,
    'floatfield2': 1.2,
    'fixedpointfield1': '1.50',
    'fixedpointfield2': '1.50',
    'booleanfield': 1,
    'imagefield': '<img src="%s/dummy/imagefield" alt="Spam" title="Spam" height="16" width="16" />' % portal_name
    }

empty_values = {
    'objectfield': None,
    'stringfield': '',
    'filefield': None,
    'textfield': '',
    'datetimefield': '2007-00-00',
    'linesfield': (),
    'integerfield': None,
    'floatfield': None,
    'floatfield2': None,
    'fixedpointfield1': None,
    'fixedpointfield2': None,
    'booleanfield': None,
    }

schema = Schema(tuple(field_instances))
sampleDisplayList = DisplayList([('e1', 'e1'), ('element2', 'element2')])

class sampleInterfaceVocabulary:
    implements(IVocabulary)

    def getDisplayList(self, instance):
        return sampleDisplayList


class Dummy(BaseContentMixin):
    def Title(self):
        # required for ImageField
        return 'Spam'

    def aMethod(self):
        return sampleDisplayList

    def default_val(self):
        return "World"


class DummyVocabulary(object):
    implements(IVocabularyFactory)

    def __call__(self, context):
        return SimpleVocabulary.fromItems([("title1", "value1"), ("t2", "v2")])

DummyVocabFactory = DummyVocabulary()

class DummyIntVocabulary(object):
    implements(IVocabularyFactory)

    def __call__(self, context):
        return SimpleVocabulary.fromItems([("title1", 1), ("t2", 2)])


DummyIntVocabFactory = DummyIntVocabulary() 


class FakeRequest:

    def __init__(self):
        self.other = {}
        self.form = {}


class ProcessingTest(ATSiteTestCase):

    def afterSetUp(self):
        self.setRoles(['Manager'])
        ATSiteTestCase.afterSetUp(self)
        self._dummy = mkDummyInContext(Dummy, oid='dummy', context=self.portal,
                                       schema=schema)
        txt_file.seek(0)
        img_file.seek(0)
        pdf_file.seek(0)

    def makeDummy(self):
        return self._dummy

    def test_processing(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        request.form.update(field_values)
        dummy.REQUEST = request
        dummy.processForm(data=1)
        for k, v in expected_values.items():
            got = dummy.getField(k).get(dummy)
            if isinstance(got, File):
                got = str(got)
            self.assertEqual(got, v, 'got: %r, expected: %r, field "%s"' %
                              (got, v, k))

    def test_processing_fieldset(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        request.form.update(field_values)
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        dummy.processForm()
        for k, v in expected_values.items():
            got = dummy.getField(k).get(dummy)
            if isinstance(got, (File, Image)):
                got = str(got)
            self.assertEqual(got, v, 'got: %r, expected: %r, field "%s"' %
                              (got, v, k))

    def test_image_tag(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        request.form.update(field_values)
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        dummy.processForm()

        image_field = dummy.getField('imagefield')
        self.assertEqual(image_field.tag(dummy),
                          '<img src="%s/dummy/imagefield" alt="Spam" title="Spam" height="16" width="16" />' % portal_name)
        self.assertEqual(image_field.tag(dummy, alt=''),
                          '<img src="%s/dummy/imagefield" alt="" title="Spam" height="16" width="16" />' % portal_name)
        self.assertEqual(image_field.tag(dummy, alt='', title=''),
                          '<img src="%s/dummy/imagefield" alt="" title="" height="16" width="16" />' % portal_name)

    def test_gif_format_preserved_when_scaling(self):
        dummy = self.makeDummy()

        image_field = dummy.getField('imagefield')

        scaled_image_file, img_format = image_field.scale(img_content, 5, 5)
        self.assertEqual("gif", img_format)

        image = PIL.Image.open(scaled_image_file)
        self.assertEqual("GIF", image.format)

    def test_dont_scale_animated_gif_when_original_is_smaller_than_scale_size(self):
        dummy = self.makeDummy()

        image_field = dummy.getField('imagefield')

        scaled_image_file, img_format = image_field.scale(animated_gif_content, 100, 100)
        self.assertEqual("gif", img_format)

        image = PIL.Image.open(scaled_image_file)
        self.assertEqual("GIF", image.format)
        image.seek(image.tell() + 1)

    def test_get_size(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        request.form.update(field_values)
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        dummy.processForm()
        size = 0
        for k, v in expected_values.items():
            field = dummy.getField(k)
            s = field.get_size(dummy)
            size += s
            self.assertTrue(s, 'got: %s, field: %s' % (s, k))
        self.assertEqual(size, dummy.get_size())

    def test_validation(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        request.form.update(field_values)
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        errors = {}
        dummy.validate(REQUEST=request, errors=errors)
        self.assertFalse(errors, errors)

    def test_validation_visible_fields(self):
        """ we assume that every field is visible """

        dummy = self.makeDummy()
        request = TestRequest()
        alsoProvides(request, IAttributeAnnotatable)
        my_values = field_values.copy()
        my_values['fixedpointfield2'] = 'an_error'
        request.form.update(my_values)
        request.form['fieldset'] = 'default'
        errors = {}
        dummy.validate(errors=errors, REQUEST=request)
        self.assertTrue(errors, errors)

    def test_validation_invisible_fields(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        my_values = field_values.copy()
        my_values['fixedpointfield2'] = 'an_error'
        request.form.update(my_values)
        request.form['fieldset'] = 'default'

        for field in dummy.Schema().filterFields(__name__='fixedpointfield2'):
            field.widget.visible['edit'] = 'invisible'
        errors = {}
        dummy.validate(errors=errors, REQUEST=request)
        self.assertFalse(errors, errors)

    def test_validation_hidden_fields(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        my_values = field_values.copy()
        my_values['fixedpointfield2'] = 'an_error'
        request.form.update(my_values)
        request.form['fieldset'] = 'default'
        for field in dummy.Schema().filterFields(__name__='fixedpointfield2'):
            field.widget.visible['edit'] = 'hidden'
        errors = {}
        dummy.validate(errors=errors, REQUEST=request)
        self.assertFalse(errors, errors)

    def test_double_validation(self):
        """ If a field already has an error and it is validated again,
        we cut the validation short and return the original error.

        Here we test that we do not lose the original error in the
        process.  We do that by adding the fieldsets twice in the
        request, which can happen if you have some whacky javascript
        that tries to clone too many inputs.
        """
        dummy = self.makeDummy()
        request = TestRequest()
        alsoProvides(request, IAttributeAnnotatable)
        my_values = field_values.copy()
        my_values['fixedpointfield2'] = 'an_error'
        request.form.update(my_values)
        request.form['fieldset'] = 'default'
        request.form['fieldsets'] = ['default', 'default']
        errors = {}
        dummy.validate(errors=errors, REQUEST=request)
        self.assertTrue(errors, errors)
        # The validation error looks a bit weird because of the
        # [[plone]] domain that is added by the translation testing
        # machinery.
        self.assertEqual(errors['fixedpointfield2'],
                         (u"[[plone][Validation failed(isDecimal): "
                          "'an_error' [[plone][is not a decimal number.]]]]"))

    def test_required(self):
        request = FakeRequest()
        request.form.update(empty_values)
        request.form['fieldset'] = 'default'
        self._test_required(request)

    def test_required_empty_request(self):
        request = FakeRequest()
        request.form = {}
        request.form['fieldset'] = 'default'
        self._test_required(request)

    def _test_required(self, request):
        dummy = self.makeDummy()
        f_names = []

        schema = dummy.Schema()
        for f in schema.fields():
            name = f.getName()
            f.required = 1
            f_names.append(name)
        errors = {}
        dummy.validate(REQUEST=request, errors=errors)
        self.assertTrue(errors, "Errors dictionary is empty.")
        err_fields = errors.keys()
        failures = []
        for f_name in f_names:
            if f_name not in err_fields:
                failures.append(f_name)
        self.assertFalse(failures, "%s failed to report error." % failures)

    def test_static_vocabulary(self):
        dummy = self.makeDummy()
        field = dummy.Schema().fields()[0]

        # Default
        self.assertEqual(field.Vocabulary(), DisplayList())
        # DisplayList
        field.vocabulary = sampleDisplayList()
        self.assertEqual(field.Vocabulary(), sampleDisplayList)
        # List
        field.vocabulary = ['e1', 'element2']
        self.assertEqual(field.Vocabulary(), sampleDisplayList)
        # 2-Tuples
        field.vocabulary = [('e1', 'e1'), ('element2', 'element2')]
        self.assertEqual(field.Vocabulary(), sampleDisplayList)

    def test_dynamic_vocabulary(self):
        dummy = self.makeDummy()
        field = dummy.Schema().fields()[0]

        # Default
        self.assertEqual(field.Vocabulary(dummy), DisplayList())
        # Method
        field.vocabulary = 'aMethod'
        self.assertEqual(field.Vocabulary(dummy), sampleDisplayList)
        # DisplayList
        field.vocabulary = sampleDisplayList()
        self.assertEqual(field.Vocabulary(dummy), sampleDisplayList)
        # List
        field.vocabulary = ['e1', 'element2']
        self.assertEqual(field.Vocabulary(dummy), sampleDisplayList)
        # 2-Tuples
        field.vocabulary = [('e1', 'e1'), ('element2', 'element2')]
        self.assertEqual(field.Vocabulary(dummy), sampleDisplayList)
        # Interface
        field.vocabulary = sampleInterfaceVocabulary()
        self.assertEqual(field.Vocabulary(dummy), sampleDisplayList)

    def test_factory_vocabulary(self):
        dummy = self.makeDummy()
        field = dummy.Schema().fields()[0]

        # Default
        self.assertEqual(field.Vocabulary(dummy), DisplayList())

        expected = DisplayList([('value1', 'title1'), ('v2', 't2')])

        # # Vocabulary factory
        field.vocabulary = ()
        field.vocabulary_factory = 'archetypes.tests.dummyvocab'
        getSiteManager().registerUtility(component=DummyVocabFactory, name='archetypes.tests.dummyvocab')
        self.assertEqual(field.Vocabulary(dummy), expected)
        getSiteManager().unregisterUtility(component=DummyVocabFactory, name='archetypes.tests.dummyvocab')

    def test_factory_vocabulary_int(self):
        dummy = self.makeDummy()
        request = FakeRequest()
        field = dummy.Schema().fields()[0]

        # Default
        self.assertEqual(field.Vocabulary(dummy), IntDisplayList())

        expected = IntDisplayList([(1, 'title1'), (2, 't2')])

        # # Vocabulary factory
        field.vocabulary = ()
        field.vocabulary_factory = 'archetypes.tests.dummyintvocab'
        getSiteManager().registerUtility(component=DummyIntVocabFactory, name='archetypes.tests.dummyintvocab')
        self.assertEqual(field.Vocabulary(), expected)
        getSiteManager().unregisterUtility(component=DummyIntVocabFactory, name='archetypes.tests.dummyintvocab')

    def test_allowable_content_types_ok(self):
        dummy = self.makeDummy()
        request = TestRequest()
        request.form.update(field_values)
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        errors = {}
        dummy.validate(REQUEST=request, errors=errors)
        self.assertFalse(errors, errors)

    def test_allowable_content_types_ofs_image_field(self):
        dummy = self.makeDummy()
        request = TestRequest()
        request.form.update(field_values)
        image = dummy.getField('imagefield')
        image.set(dummy, img_file)
        image = image.getAccessor(dummy)()
        # we need to set the filename to blank otherwise the mimetypes_registry
        # will pick up the correct mimetype from the filename and we need to
        # test a situation where the image field is of type Image from
        # Archetypes fields and the OFS image uploaded within it has no
        # filename set
        image.filename = ""
        image_file = image.data

        request.form.update({'imagefield_file': image_file})
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        errors = {}
        dummy.validate(REQUEST=request, errors=errors)
        self.assertFalse(errors, errors)

    def test_allowable_content_types_fail(self):
        dummy = self.makeDummy()
        request = TestRequest()
        request.form.update(field_values)
        request.form.update({'imagefield_file': pdf_file})
        request.form['fieldset'] = 'default'
        dummy.REQUEST = request
        errors = {}
        dummy.validate(REQUEST=request, errors=errors)
        self.assertTrue(errors, errors)

    def test_defaults(self):
        dummy = self.makeDummy()
        field = dummy.Schema().fields()[0]

        # Default
        self.assertEqual(field.getDefault(dummy), None)

        # Value
        field.default = "Hello"
        self.assertEqual(field.getDefault(dummy), 'Hello')

        # Method
        field.default = None
        field.default_method = 'default_val'
        self.assertEqual(field.getDefault(dummy), 'World')

        # Adapter
        field.default_method = None

        class DefaultFor(object):
            implements(IFieldDefaultProvider)

            def __init__(self, context):
                self.context = context

            def __call__(self):
                return "Adapted"

        getSiteManager().registerAdapter(factory=DefaultFor, required=(Dummy,), name=field.__name__)
        self.assertEqual(field.getDefault(dummy), 'Adapted')
        getSiteManager().unregisterAdapter(factory=DefaultFor, required=(Dummy,), name=field.__name__)

    def test_encoding(self):
        # http://dev.plone.org/plone/ticket/7597
        dummy = self.makeDummy()
        field = dummy.Schema().fields()[3]  # textfield
        field.set(self.portal, 'some_text_with_weird_encoding', encoding='latin')
        encoding = field.getRaw(self.portal, raw=1).original_encoding
        self.assertEqual(encoding, 'latin')

    def test_mimetype(self):
        dummy = self.makeDummy()
        field = TextField('test', default_content_type='text/html')
        dummy.test = ''
        mimetype = field.getContentType(dummy)
        self.assertEqual('text/html', mimetype)


class DownloadTest(ATSiteTestCase):

    def afterSetUp(self):
        # Set up a content object with a field that has a word
        # document in it
        ATSiteTestCase.afterSetUp(self)
        self.dummy = mkDummyInContext(
            Dummy, oid='dummy', context=self.portal, schema=schema)
        self.field = self.dummy.getField('textfield')
        ptpath = PortalTransforms.__path__[0]
        self.wordfile = open('%s/tests/input/test.doc' % ptpath)
        self.field.getMutator(self.dummy)(self.wordfile.read())
        self.request = self.app.REQUEST
        self.response = self.request.response

    def test_download_from_textfield(self):
        # make sure field data doesn't get transformed when using the
        # download method
        value = self.field.download(self.dummy, no_output=True)
        self.assertFalse(isinstance(value, str))

    # XXX This test produces an UnicodeEncodeError in default Archetypes
    def DISABLED_test_download_filename_encoding(self):
        # When downloading, the filename is converted to ASCII:
        self.field.setFilename(self.dummy, '\xc3\xbcberzeugen')
        self.field.download(self.dummy, no_output=True)
        self.assertEqual(self.response.headers['content-disposition'],
                         'attachment; filename="uberzeugen"')


def test_suite():
    suite = TestSuite()
    suite.addTest(makeSuite(ProcessingTest))
    suite.addTest(makeSuite(DownloadTest))
    return suite
