# -*- coding:utf-8 -*-
from django.db.models import TextField
#from django.core import validators
try:
    from django import newforms as forms
except:
    from django import forms

from django.utils.functional import curry

try:
    from django.utils.encoding import smart_unicode
except:
    from django.newforms.util import smart_unicode 
try:
    from django.oldforms import LargeTextField
    LARGE_TEXTFIELD = True
except:
	try:
		from django.forms import LargeTextField
		LARGE_TEXTFIELD = True
	except:
		LARGE_TEXTFIELD = False
	

try:
    from django.newforms import widgets
    from django.newforms import fields
except:
    from django.forms import widgets
    from django.forms import fields

import types
try:
    from django.utils.safestring import mark_safe
except ImportError:
    def mark_safe(s):
        return s

import datetime

def rest2htmlbody(data):
#from docutils import nodes, utils
    from docutils.core import publish_parts
    from docutils.writers import html4css1
    parts = publish_parts(data, writer=html4css1.Writer(), settings_overrides={'input_encoding': 'utf-8'})
    return parts['body'].encode('utf-8')


class ReadOnlyTextInput(forms.TextInput):
    def __init__(self, *args, **kwargs):
        kwargs.setdefault('attrs',{}).update({'readonly': True,
                'style':"background-color:#FFF3C8; border:0px"})
        super(ReadOnlyTextInput, self).__init__(*args, **kwargs)


if LARGE_TEXTFIELD:
	class FormRestField(LargeTextField):
		input_type = "text"
		def __init__(self, field_name, rows=25, cols=100, is_required=False, validator_list=None, maxlength=None):
			if validator_list is None: validator_list = []
			self.field_name = field_name
			self.rows, self.cols, self.is_required = rows, cols, is_required
			self.validator_list = validator_list[:]
			if maxlength:
				self.validator_list.append(self.isValidLength)
				self.maxlength = maxlength

		def render(self, data):
			if data is None:
				data = ''

			js_preview = '''<script type="text/javascript">
			<!--
			function hide_%s_preview(){
			  field_id = "%s";
			  document.getElementById(field_id + "-preview").style.display = "none";
			  document.getElementById(field_id).style.display = "inline";
			  document.getElementById("hide-" + field_id + "-button").style.display = "none";
			  document.getElementById("show-" + field_id + "-button").style.display = "inline";
			}
			function show_%s_preview(){
			  field_id = "%s";
			  document.getElementById(field_id + "-preview").style.display = "block";
			  document.getElementById(field_id).style.display = "none";
			  document.getElementById("hide-" + field_id + "-button").style.display = "inline";
			  document.getElementById("show-" + field_id + "-button").style.display = "none";
			}
			-->
			</script>
			<input class="default" type="button" value="Mode édition" id="hide-%s-button" onclick="hide_%s_preview()" style="display: none;" />
			<input class="default" type="button" value="Mode preview" id="show-%s-button" onclick="show_%s_preview()" />
			''' % (self.field_name, self.get_id(), self.field_name, self.get_id(), self.get_id(), self.field_name, self.get_id(), self.field_name,)

			return js_preview + '''<table><tr>
			<td><textarea id="%s" class="v%s%s" name="%s" rows="%s" cols="%s" style="font-family:monospace">%s</textarea></td>
			<td><div id="%s-preview" style="border: 1px solid #ccc; max-height:%sem; width: %sem; overflow:auto; display: none;">%s</div></td>
			</tr></table>''' % (self.get_id(), self.__class__.__name__, self.is_required and ' required' or '', self.field_name, self.rows,
								self.cols, data, self.get_id(),
								int(self.rows*1.5),
								int(self.cols*0.65) ,
								rest2htmlbody(data))

		def html2python(data):
			return data
		html2python = staticmethod(html2python)


	def get_FIELD_rst2html(instance, field):
		return rest2htmlbody(getattr(instance, field.name))


class RestField(TextField):

    def contribute_to_class(self, cls, name):
        super(RestField, self).contribute_to_class(cls, name)
        setattr(cls, 'get_%s_html' % self.name, curry(get_FIELD_rst2html, field=self))

    def isValid(self, field_data, all_data):
        # TODO : lancer publish_parts et chopper les erreurs
        pass
    
    def get_internal_type(self):
        return "TextField"

    def get_manipulator_field_objs(self):
        return [FormRestField]
    

class DateTimeInput(widgets.Input):
    """ C/C du trunk de django."""
    input_type = 'text'
    format = '%Y-%m-%d %H:%M:%S'     # '2006-10-25 14:30:59'

    def __init__(self, attrs=None, format=None):
        super(DateTimeInput, self).__init__(attrs)
        if format:
            self.format = format

    def render(self, name, value, attrs=None):
        if value is None:
            value = ''
        elif hasattr(value, 'strftime'):
            value = value.strftime(self.format)
        return super(DateTimeInput, self).render(name, value, attrs)


class ISODateInput(widgets.TextInput):
    def __init__(self, *args, **kwargs):
        super(ISODateInput, self).__init__(*args, **kwargs)
    
    def render(self, name, value, attrs=None):
        if value is None: value = ''
        final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
        if value:
            if type(value) != types.StringType:
                # Hope it's datetime.date
                value = value.strftime("%Y-%m-%d")
            final_attrs['value'] = value

        if final_attrs.has_key('calendar'):
            if final_attrs['calendar']:
                return (u"<input%s />"
                        " <script language='javascript'>"
                        " var inp = document.getElementById('%s');"
                        "addCalendar(inp, '%s', 'english', false);"
                        "</script>" %(widgets.flatatt(final_attrs), final_attrs['id'],\
                                      final_attrs['calendar_class'],))
        return (u"<input%s />" %(widgets.flatatt(final_attrs),))


class FrenchDateInput(widgets.TextInput):
    def __init__(self, *args, **kwargs):
        super(FrenchDateInput, self).__init__(*args, **kwargs)
    
    def render(self, name, value, attrs=None):
        if value is None: value = ''
        final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
        if value:
            if type(value) not in (types.StringType, types.UnicodeType):
                # Hope it's datetime.date
                value = u'%.2d/%.2d/%.4d' % (value.day, value.month, value.year)
            final_attrs['value'] = value

        if final_attrs.has_key('calendar'):
            args = final_attrs['calendar']
            if args:
                if type(args) not in (types.StringType, types.UnicodeType):
                    args = ''                
                return (mark_safe(u"<input%s />" \
                        "<script type=\"text/javascript\">" \
                        "$(document).ready(function() { $('#%s').datepicker(%s); });" \
                        "</script>" % (widgets.flatatt(final_attrs), 
                                       final_attrs['id'],
                                       args)))


        return (mark_safe(u"<input%s />" %(widgets.flatatt(final_attrs),)))



class TimeInput(widgets.TextInput):
    # Contact fredz@pimentech.fr if you need to pass other format
    format = '%H:%M' # :%S'
    def __init__(self, *args, **kwargs):
        super(TimeInput, self).__init__(*args, **kwargs)
    
    def render(self, name, value, attrs=None):
        if value is None: value = ''
        final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
        if type(value) not in (types.StringType, types.UnicodeType):
            # Hope it's datetime.time
            value = value.strftime(self.format)
        final_attrs['value'] = value

        return (mark_safe(u'<input style="width:5em" %s />' %(widgets.flatatt(final_attrs),)))



class SplitFrenchDateTimeWidget(widgets.MultiWidget):
    def __init__(self, attrs=None):
        widgts = (FrenchDateInput(attrs=attrs), TimeInput(attrs=attrs))
        super(SplitFrenchDateTimeWidget, self).__init__(widgts, attrs)

    def decompress(self, value):
        if value:
            return [value.date(), value.time()]
        return [None, None]




FRENCH_DATE_INPUT_FORMATS = (
    '%Y-%m-%d', '%d/%m/%Y', '%d/%m/%y', # '2006-10-25', '25/10/2006', '25/10/06'
    '%d %b %Y',                         # '25 Oct 2006'
    '%d %B %Y',                         # '25 October 2006', 'October 25, 2006'
)

class FrenchDateField(fields.DateField):
    widget = FrenchDateInput
    def __init__(self, *args, **kwargs):
        super(FrenchDateField, self).__init__(
            FRENCH_DATE_INPUT_FORMATS, *args, **kwargs
            )

class SplitFrenchDateTimeField(fields.MultiValueField):
    def __init__(self, *args, **kwargs):
        ffields = (FrenchDateField(), fields.TimeField(input_formats=('%H:%M',)))
        super(SplitFrenchDateTimeField, self).__init__(ffields, *args, **kwargs)

    def compress(self, data_list):
        if data_list:
            if data_list[0] and  data_list[1]:
                return datetime.datetime.combine(*data_list)
            if data_list[0] and not data_list[1]:
                return data_list[0]
        return None




class ChainedSelectInput(forms.HiddenInput):
    """ Class made to be used with jquery.chainedselect.js. Use it as widget on a hidden field
    and ( levels ) selects will appear, populated with js_data_variable.

    js_data_variable structure : 
    ----------------------------

    [ {'value': 12
       'text': 'hum hum'
       'sub_tree': [ { ... }, { ... } ]
      },
      { ... }
    ]
    
    Django use example :
    --------------------

    class CustomerForm(forms.ModelForm)
        city = forms.IntegerField(required=True, 
                                  widget=ChainedSelectInput('ORDERED_CITIES', 2), 
                                  label=_('Location')
                                 )

        class Meta:
            model = models.Customer
            fields = ('city', )

        def clean_city(self):
            try:
                return models.City.objects.get(id=self.cleaned_data['city'])
            except models.City.DoesNotExist:
                raise ValidationError(_('This city does not exist'))
    """

    def __init__(self, js_data_variable, levels, attrs=None):
        self.js_data_variable = js_data_variable
        self.levels = levels
        super(ChainedSelectInput, self).__init__(attrs)

    def render_selects(self, select_list, hidden_field):
        return hidden_field + ''.join(select_list)

    def render(self, name, value, attrs=None):
        if value is None: value = ''
        hidden_field = super(ChainedSelectInput, self).render(name, value, attrs)
        level = self.levels-1

        select_list = []
        while (level>=0):
            selname = u'%s_level_%s' % (name, level)
            select_list.append(u'<select id="id_%s" name="%s"></select>' % (selname, selname))
            level = level - 1
        
        render = self.render_selects(select_list, hidden_field)

        render += u'<script type="text/javascript">' \
            '$(document).ready(function() { initChainedSelect(\'id_%s\', %s, %s); });' \
            '</script>' % (name, self.js_data_variable, self.levels)

        return mark_safe(render)