package HTML::FormFu::Role::Element::Field;
$HTML::FormFu::Role::Element::Field::VERSION = '2.01';
use Moose::Role;
use MooseX::Aliases;
use MooseX::Attribute::FormFuChained;

with 'HTML::FormFu::Role::ContainsElementsSharedWithField',
    'HTML::FormFu::Role::NestedHashUtils',
    'HTML::FormFu::Role::FormBlockAndFieldMethods',
    'HTML::FormFu::Role::Element::Layout';

use HTML::FormFu::Attribute qw(
    mk_attrs
    mk_output_accessors
);
use HTML::FormFu::Constants qw( $EMPTY_STR );
use HTML::FormFu::Util qw(
    _parse_args                 append_xml_attribute
    xml_escape                  require_class
    process_attrs               _filter_components
);
use Class::MOP::Method;
use Clone ();
use List::MoreUtils qw( uniq );
use Carp qw( croak carp );

__PACKAGE__->mk_attrs( qw(
        comment_attributes
        container_attributes
        label_attributes
        error_attributes
        error_container_attributes
) );

has _constraints         => ( is => 'rw', traits => ['FormFuChained'] );
has _filters             => ( is => 'rw', traits => ['FormFuChained'] );
has _inflators           => ( is => 'rw', traits => ['FormFuChained'] );
has _deflators           => ( is => 'rw', traits => ['FormFuChained'] );
has _validators          => ( is => 'rw', traits => ['FormFuChained'] );
has _transformers        => ( is => 'rw', traits => ['FormFuChained'] );
has _plugins             => ( is => 'rw', traits => ['FormFuChained'] );
has _errors              => ( is => 'rw', traits => ['FormFuChained'] );
has container_tag        => ( is => 'rw', traits => ['FormFuChained'] );
has field_filename       => ( is => 'rw', traits => ['FormFuChained'] );
has label_filename       => ( is => 'rw', traits => ['FormFuChained'] );
has label_tag            => ( is => 'rw', traits => ['FormFuChained'] );
has retain_default       => ( is => 'rw', traits => ['FormFuChained'] );
has force_default        => ( is => 'rw', traits => ['FormFuChained'] );
has javascript           => ( is => 'rw', traits => ['FormFuChained'] );
has non_param            => ( is => 'rw', traits => ['FormFuChained'] );
has reverse_single       => ( is => 'rw', traits => ['FormFuChained'] );
has reverse_multi        => ( is => 'rw', traits => ['FormFuChained'] );
has multi_value          => ( is => 'rw', traits => ['FormFuChained'] );
has original_name        => ( is => 'rw', traits => ['FormFuChained'] );
has original_nested_name => ( is => 'rw', traits => ['FormFuChained'] );
has default_empty_value  => ( is => 'rw', traits => ['FormFuChained'] );

__PACKAGE__->mk_output_accessors(qw( comment label value ));

alias( "default",     "value" );
alias( "default_xml", "value_xml" );
alias( "default_loc", "value_loc" );

after BUILD => sub {
    my $self = shift;

    $self->_constraints(  [] );
    $self->_filters(      [] );
    $self->_deflators(    [] );
    $self->_inflators(    [] );
    $self->_validators(   [] );
    $self->_transformers( [] );
    $self->_plugins(      [] );
    $self->_errors(       [] );
    $self->comment_attributes(         {} );
    $self->container_attributes(       {} );
    $self->label_attributes(           {} );
    $self->error_attributes(           {} );
    $self->error_container_attributes( {} );
    $self->label_filename('label');
    $self->label_tag('label');
    $self->container_tag('div');
    $self->is_field(1);

    return;
};

sub nested {
    my ($self) = @_;

    croak 'cannot set nested' if @_ > 1;

    if ( defined $self->name ) {
        my $parent = $self;

        while ( defined( $parent = $parent->parent ) ) {

            if ( $parent->can('is_field') && $parent->is_field ) {
                return 1 if defined $parent->name;
            }
            else {
                return 1 if defined $parent->nested_name;
            }
        }
    }

    return;
}

sub nested_name {
    my ($self) = @_;

    croak 'cannot set nested_name' if @_ > 1;

    return if !defined $self->name;

    my @names = $self->nested_names;

    if ( $self->form->nested_subscript ) {
        my $name = shift @names;
        map { $name .= "[$_]" } @names;

     # TODO - Mario Minati 19.05.2009
     # Does this (name formatted as '[name]') collide with FF::Model::HashRef as
     # it uses /_\d/ to parse repeatable names?
        return $name;
    }
    else {
        return join ".", @names;
    }
}

sub nested_names {
    my ($self) = @_;

    croak 'cannot set nested_names' if @_ > 1;

    if ( defined( my $name = $self->name ) ) {
        my @names;
        my $parent = $self;

        # micro optimization! this method's called a lot, so access
        # parent hashkey directly, instead of calling parent()
        while ( defined( $parent = $parent->{parent} ) ) {

            if ( $parent->can('is_field') && $parent->is_field ) {

                # handling Field
                push @names, $parent->name
                    if defined $parent->name;
            }
            elsif ( $parent->can('is_repeatable') && $parent->is_repeatable ) {

                # handling Repeatable
                # ignore Repeatables nested_name attribute as it is provided
                # by the childrens Block elements
            }
            else {

                # handling 'not Field' and 'not Repeatable'
                push @names, $parent->nested_name
                    if defined $parent->nested_name;
            }
        }

        if (@names) {
            return reverse $name, @names;
        }
    }

    return ( $self->name );
}

sub build_original_nested_name {
    my ($self) = @_;

    croak 'cannot set build_original_nested_name' if @_ > 1;

    return if !defined $self->name;

    my @names = $self->build_original_nested_names;

    if ( $self->form->nested_subscript ) {
        my $name = shift @names;
        map { $name .= "[$_]" } @names;

     # TODO - Mario Minati 19.05.2009
     # Does this (name formatted as '[name]') collide with FF::Model::HashRef as
     # it uses /_\d/ to parse repeatable names?
        return $name;
    }
    else {
        return join ".", @names;
    }
}

sub build_original_nested_names {
    my ($self) = @_;

    croak 'cannot set build_original_nested_names' if @_ > 1;

    # TODO - Mario Minati 19.05.2009
    # Maybe we have to use original_name instead of name.
    # Yet there is no testcase, which is currently failing.

    if ( defined( my $name = $self->name ) ) {
        my @names;
        my $parent = $self;

        # micro optimization! this method's called a lot, so access
        # parent hashkey directly, instead of calling parent()
        while ( defined( $parent = $parent->{parent} ) ) {

            if ( $parent->can('is_field') && $parent->is_field ) {

                # handling Field
                if ( defined $parent->original_name ) {
                    push @names, $parent->original_name;
                }
                elsif ( defined $parent->name ) {
                    push @names, $parent->name;
                }
            }
            elsif ( $parent->can('is_repeatable') && $parent->is_repeatable ) {

     # handling Repeatable
     # TODO - Mario Minati 19.05.2009
     # Do we have to take care of chains of Repeatable elements, if the Block
     # elements have already been created for the outer Repeatable elements to
     # avoid 'outer.outer_1.inner'
     # Yet there is no failing testcase. All testcases in FF and FF::Model::DBIC
     # which have nested repeatable elements are passing currently.
                push @names, $parent->original_nested_name
                    if defined $parent->original_nested_name;
            }
            else {

                # handling 'not Field' and 'not Repeatable'
                if ( $parent->can('original_nested_name')
                    && defined $parent->original_nested_name )
                {
                    push @names, $parent->original_nested_name;
                }
                elsif ( defined $parent->nested_name ) {
                    push @names, $parent->nested_name;
                }
            }
        }

        if (@names) {
            return reverse $name, @names;
        }
    }

    return ( $self->name );
}

sub nested_base {
    my ($self) = @_;

    croak 'cannot set nested_base' if @_ > 1;

    my $parent = $self;

    while ( defined( $parent = $parent->parent ) ) {

        return $parent->nested_name if defined $parent->nested_name;
    }
}

sub get_deflators {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_deflators };

    return _filter_components( \%args, \@x );
}

sub get_filters {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_filters };

    return _filter_components( \%args, \@x );
}

sub get_constraints {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_constraints };

    return _filter_components( \%args, \@x );
}

sub get_inflators {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_inflators };

    return _filter_components( \%args, \@x );
}

sub get_validators {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_validators };

    return _filter_components( \%args, \@x );
}

sub get_transformers {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_transformers };

    return _filter_components( \%args, \@x );
}

sub get_errors {
    my $self = shift;
    my %args = _parse_args(@_);

    my @x = @{ $self->_errors };

    _filter_components( \%args, \@x );

    if ( !$args{forced} ) {
        @x = grep { !$_->forced } @x;
    }

    return \@x;
}

sub clear_errors {
    my ($self) = @_;

    $self->_errors( [] );

    return;
}

after pre_process => sub {
    my $self = shift;

    for my $plugin ( @{ $self->_plugins } ) {
        $plugin->pre_process;
    }

    return;
};

after process => sub {
    my $self = shift;

    for my $plugin ( @{ $self->_plugins } ) {
        $plugin->process;
    }

    return;
};

after post_process => sub {
    my $self = shift;

    for my $plugin ( @{ $self->_plugins } ) {
        $plugin->post_process;
    }

    return;
};

sub process_input {
    my ( $self, $input ) = @_;

    my $submitted = $self->form->submitted;
    my $default   = $self->default;
    my $original  = $self->value;
    my $name      = $self->nested_name;

    # set input to default value (defined before calling FormFu->process)
    if ( $submitted && $self->force_default && defined $default ) {
        $self->set_nested_hash_value( $input, $name, $default );
    }

    # checkbox, radio
    elsif ($submitted
        && $self->force_default
        && $self->can('checked')
        && $self->checked )
    {

        # the checked attribute is set, so force input to be the original value
        $self->set_nested_hash_value( $input, $name, $original );
    }

    # checkbox, radio
    elsif ($submitted
        && $self->force_default
        && !defined $default
        && defined $original )
    {

    # default and value are not equal, so this element is not checked by default
        $self->set_nested_hash_value( $input, $name, undef );
    }

    return;
}

sub prepare_id {
    my ( $self, $render ) = @_;

    if (  !defined $render->{attributes}{id}
        && defined $self->auto_id
        && length $self->auto_id )
    {
        my $form_name
            = defined $self->form->id
            ? $self->form->id
            : $EMPTY_STR;

        my $field_name
            = defined $render->{nested_name}
            ? $render->{nested_name}
            : $EMPTY_STR;

        my %string = (
            f => $form_name,
            n => $field_name,
        );

        my $id = $self->auto_id;
        $id =~ s/%([fn])/$string{$1}/g;

        if ( defined( my $count = $self->repeatable_count ) ) {
            $id =~ s/%r/$count/g;
        }

        $render->{attributes}{id} = $id;
    }

    return;
}

sub process_value {
    my ( $self, $value ) = @_;

    my $submitted = $self->form->submitted;
    my $default   = $self->default;

    my $new;

    if ($submitted) {
        if ( defined $value ) {
            $new = $value;
        }
        elsif ( defined $default ) {
            $new = $EMPTY_STR;
        }
    }
    else {
        $new = $default;
    }

    if (   $submitted
        && $self->retain_default
        && defined $new
        && $new eq $EMPTY_STR )
    {
        $new = $default;
    }

    # if the default value has been changed after FormFu->process has been
    # called we use it and set the value to that changed default again
    if (   $submitted
        && $self->force_default
        && defined $default
        && $new ne $default )
    {
        $new = $default;
    }

    return $new;
}

around render_data_non_recursive => sub {
    my ( $orig, $self, $args ) = @_;

    my $render = $self->$orig( {
            nested_name          => xml_escape( $self->nested_name ),
            comment_attributes   => xml_escape( $self->comment_attributes ),
            container_attributes => xml_escape( $self->container_attributes ),
            label_attributes     => xml_escape( $self->label_attributes ),
            comment              => xml_escape( $self->comment ),
            label                => xml_escape( $self->label ),
            field_filename       => $self->field_filename,
            label_filename       => $self->label_filename,
            label_tag            => $self->label_tag,
            container_tag        => $self->container_tag,
            error_container_tag  => $self->error_container_tag,
            error_tag            => $self->error_tag,
            reverse_single       => $self->reverse_single,
            reverse_multi        => $self->reverse_multi,
            javascript           => $self->javascript,
            $args ? %$args : (),
        } );

    $self->_render_container_class($render);
    $self->_render_comment_class($render);
    $self->_render_label($render);
    $self->_render_value($render);
    $self->_render_constraint_class($render);
    $self->_render_inflator_class($render);
    $self->_render_validator_class($render);
    $self->_render_transformer_class($render);
    $self->_render_error_class($render);

    return $render;
};

sub _render_label {
    my ( $self, $render ) = @_;

    if (  !defined $render->{label}
        && defined $self->auto_label
        && length $self->auto_label )
    {
        my %string = (
            f => defined $self->form->id ? $self->form->id : '',
            n => defined $render->{name} ? $render->{name} : '',
        );

        my $label = $self->auto_label;
        $label =~ s/%([fn])/$string{$1}/g;

        $render->{label} = $self->form->localize($label);
    }

    if (    defined $render->{label}
         && defined $self->auto_label_class
         && length $self->auto_label_class
        )
    {
        my $form_name
            = defined $self->form->id
            ? $self->form->id
            : $EMPTY_STR;

        my $field_name
            = defined $render->{nested_name}
            ? $render->{nested_name}
            : $EMPTY_STR;
        
        my $type = lc $self->type;
        $type =~ s/:://g;
        
        my %string = (
            f => $form_name,
            n => $field_name,
            t => $type,
        );

        my $class = $self->auto_label_class;
        $class =~ s/%([fnt])/$string{$1}/g;
        
        append_xml_attribute( $render->{label_attributes},
            'class', $class );
    }

    if (    defined $render->{label}
         && defined $self->auto_container_label_class
         && length $self->auto_container_label_class
        )
    {
        my $form_name
            = defined $self->form->id
            ? $self->form->id
            : $EMPTY_STR;

        my $field_name
            = defined $render->{nested_name}
            ? $render->{nested_name}
            : $EMPTY_STR;
        
        my $type = lc $self->type;
        $type =~ s/:://g;
        
        my %string = (
            f => $form_name,
            n => $field_name,
            t => $type,
        );

        my $class = $self->auto_container_label_class;
        $class =~ s/%([fnt])/$string{$1}/g;
        
        append_xml_attribute( $render->{container_attributes},
            'class', $class );
    }

    # label "for" attribute
    if (   defined $render->{label}
        && defined $render->{attributes}{id}
        && !exists $render->{label_attributes}{for} )
    {
        $render->{label_attributes}{for} = $render->{attributes}{id};
    }

    return;
}

sub _render_comment_class {
    my ( $self, $render ) = @_;
    
    if (    defined $render->{comment}
         && defined $self->auto_comment_class
         && length $self->auto_comment_class
        )
    {
        my $form_name
            = defined $self->form->id
            ? $self->form->id
            : $EMPTY_STR;

        my $field_name
            = defined $render->{nested_name}
            ? $render->{nested_name}
            : $EMPTY_STR;
        
        my %string = (
            f => $form_name,
            n => $field_name,
        );

        my $class = $self->auto_comment_class;
        $class =~ s/%([fn])/$string{$1}/g;

        append_xml_attribute( $render->{comment_attributes},
            'class', $class );
    }

    if (    defined $render->{comment}
         && defined $self->auto_container_comment_class
         && length $self->auto_container_comment_class
        )
    {
        my $form_name
            = defined $self->form->id
            ? $self->form->id
            : $EMPTY_STR;

        my $field_name
            = defined $render->{nested_name}
            ? $render->{nested_name}
            : $EMPTY_STR;
        
        my %string = (
            f => $form_name,
            n => $field_name,
        );

        my $class = $self->auto_container_comment_class;
        $class =~ s/%([fn])/$string{$1}/g;

        append_xml_attribute( $render->{container_attributes},
            'class', $class );
    }

    return;
}

sub _render_value {
    my ( $self, $render ) = @_;

    my $form = $self->form;
    my $name = $self->nested_name;

    my $input;

    if (   $self->form->submitted
        && defined $name
        && $self->nested_hash_key_exists( $form->input, $name ) )
    {
        if ( $self->render_processed_value ) {
            $input
                = $self->get_nested_hash_value( $form->_processed_params, $name,
                );
        }
        else {
            $input = $self->get_nested_hash_value( $form->input, $name, );
        }
    }

    if ( ref $input eq 'ARRAY' ) {
        my $elems = $self->form->get_fields( $self->name );
        for ( 0 .. @$elems - 1 ) {
            if ( $self == $elems->[$_] ) {
                $input = $input->[$_];
            }
        }
    }

    my $value = $self->process_value($input);

    if ( !$self->form->submitted
        || ( $self->render_processed_value && defined $value ) )
    {
        for my $deflator ( @{ $self->_deflators } ) {
            $value = $deflator->process($value);
        }
    }

    # handle multiple values for the same name
    if ( ref $value eq 'ARRAY' && defined $self->name ) {
        my $max = $#$value;
        my $fields = $self->form->get_fields( name => $self->name );

        for my $i ( 0 .. $max ) {
            if ( defined $fields->[$i] && $fields->[$i] eq $self ) {
                $value = $value->[$i];
                last;
            }
        }
    }

    $render->{value} = xml_escape($value);

    return;
}

sub _render_container_class {
    my ( $self, $render ) = @_;

    if (    defined $self->auto_container_class
         && length $self->auto_container_class
        )
    {
        my $form_name
            = defined $self->form->id
            ? $self->form->id
            : $EMPTY_STR;

        my $field_name
            = defined $render->{nested_name}
            ? $render->{nested_name}
            : $EMPTY_STR;
        
        my $type = lc $self->type;
        $type =~ s/:://g;
        
        my %string = (
            f => $form_name,
            n => $field_name,
            t => $type,
        );

        my $class = $self->auto_container_class;
        $class =~ s/%([fnt])/$string{$1}/g;

        append_xml_attribute( $render->{container_attributes},
            'class', $class );
    }

    return;
}

sub _render_constraint_class {
    my ( $self, $render ) = @_;

    my $auto_class = $self->auto_constraint_class;

    return if !defined $auto_class;

    for my $c ( @{ $self->_constraints } ) {
        my %string = (
            f => defined $self->form->id ? $self->form->id : '',
            n => defined $render->{name} ? $render->{name} : '',
            t => defined $c->type        ? lc( $c->type )  : '',
        );

        $string{t} =~ s/::/_/g;
        $string{t} =~ s/\+//;

        my $class = $auto_class;

        $class =~ s/%([fnt])/$string{$1}/g;

        append_xml_attribute( $render->{container_attributes},
            'class', $class, );
    }

    return;
}

sub _render_inflator_class {
    my ( $self, $render ) = @_;

    my $auto_class = $self->auto_inflator_class;

    return if !defined $auto_class;

    for my $c ( @{ $self->_inflators } ) {
        my %string = (
            f => defined $self->form->id ? $self->form->id : '',
            n => defined $render->{name} ? $render->{name} : '',
            t => defined $c->type        ? lc( $c->type )  : '',
        );

        $string{t} =~ s/::/_/g;
        $string{t} =~ s/\+//;

        my $class = $auto_class;

        $class =~ s/%([fnt])/$string{$1}/g;

        append_xml_attribute( $render->{container_attributes},
            'class', $class, );
    }

    return;
}

sub _render_validator_class {
    my ( $self, $render ) = @_;

    my $auto_class = $self->auto_validator_class;

    return if !defined $auto_class;

    for my $c ( @{ $self->_validators } ) {
        my %string = (
            f => defined $self->form->id ? $self->form->id : '',
            n => defined $render->{name} ? $render->{name} : '',
            t => defined $c->type        ? lc( $c->type )  : '',
        );

        $string{t} =~ s/::/_/g;
        $string{t} =~ s/\+//;

        my $class = $auto_class;

        $class =~ s/%([fnt])/$string{$1}/g;

        append_xml_attribute( $render->{container_attributes},
            'class', $class, );
    }

    return;
}

sub _render_transformer_class {
    my ( $self, $render ) = @_;

    my $auto_class = $self->auto_transformer_class;

    return if !defined $auto_class;

    for my $c ( @{ $self->_transformers } ) {
        my %string = (
            f => defined $self->form->id ? $self->form->id : '',
            n => defined $render->{name} ? $render->{name} : '',
            t => defined $c->type        ? lc( $c->type )  : '',
        );

        $string{t} =~ s/::/_/g;
        $string{t} =~ s/\+//;

        my $class = $auto_class;

        $class =~ s/%([fnt])/$string{$1}/g;

        append_xml_attribute( $render->{container_attributes},
            'class', $class, );
    }

    return;
}

sub _render_error_class {
    my ( $self, $render ) = @_;

    my @errors = @{ $self->get_errors( { forced => 1 } ) };

    return if !@errors;

    @errors = map { $_->render_data } @errors;

    $render->{errors} = \@errors;

    my @container_class;

    # auto_container_error_class
    my $auto_class = $self->auto_container_error_class;

    if ( defined $auto_class && length $auto_class ) {
        my %string = (
            f => sub { defined $self->form->id ? $self->form->id   : '' },
            n => sub { defined $render->{name} ? $render->{name}   : '' },
        );

        $auto_class =~ s/%([fn])/$string{$1}->()/ge;

        push @container_class, $auto_class;
    }

    # auto_container_per_error_class
    my $item_class = $self->auto_container_per_error_class;

    if ( defined $item_class && length $item_class ) {
        for my $error (@errors) {
            my %string = (
                f => sub { defined $self->form->id ? $self->form->id   : '' },
                n => sub { defined $render->{name} ? $render->{name}   : '' },
                s => sub { $error->{stage} },
                t => sub { lc $error->{type} },
            );

            my $string = $item_class;
            $string =~ s/%([fnst])/$string{$1}->()/ge;

            push @container_class, $string;
        }
    }

    map {
        append_xml_attribute( $render->{container_attributes}, 'class', $_ )
    } uniq @container_class;

    my @error_container_class;

    if ( $self->error_container_tag ) {

        # auto_error_container_class
        my $auto_class = $self->auto_error_container_class;

        if ( defined $auto_class && length $auto_class ) {
            my %string = (
                f => sub { defined $self->form->id ? $self->form->id   : '' },
                n => sub { defined $render->{name} ? $render->{name}   : '' },
            );

            $auto_class =~ s/%([fn])/$string{$1}->()/ge;

            push @error_container_class, $auto_class;
        }

        # auto_container_per_error_class
        my $item_class = $self->auto_container_per_error_class;

        if ( defined $item_class && length $item_class ) {
            for my $error (@errors) {
                my %string = (
                    f => sub { defined $self->form->id ? $self->form->id   : '' },
                    n => sub { defined $render->{name} ? $render->{name}   : '' },
                    s => sub { $error->{stage} },
                    t => sub { lc $error->{type} },
                );

                my $string = $item_class;
                $string =~ s/%([fnst])/$string{$1}->()/ge;

                push @error_container_class, $string;
            }
        }

         map {
            append_xml_attribute( $render->{error_container_attributes}, 'class', $_ )
        } uniq @error_container_class;
    }

    return;
}

sub render_label {
    my ($self) = @_;

    my $render = $self->render_data;

    return $self->_string_label( $render );
}

sub render_field {
    my ($self) = @_;

    my $render = $self->render_data;

    return $self->_string_field( $render );
}

sub _string_field_start {
    my ( $self, $render ) = @_;

    # field wrapper template - start

    my $html = '';

    if ( defined $render->{container_tag} ) {
        $html .= sprintf '<%s%s>',
            $render->{container_tag},
            process_attrs( $render->{container_attributes} );
    }

    if ( defined $render->{label} && $render->{label_tag} eq 'legend' ) {
        $html .= sprintf "\n%s", $self->_string_label($render);
    }

    $html .= $self->_string_errors( $render );

    if (   defined $render->{label}
        && $render->{label_tag} ne 'legend'
        && !$render->{reverse_single} )
    {
        $html .= sprintf "\n%s", $self->_string_label($render);
    }

    if ( defined $render->{container_tag} ) {
        $html .= "\n";
    }

    return $html;
}

sub _string_label {
    my ( $self, $render ) = @_;

    # label template

    my $html = sprintf "<%s%s>%s</%s>",
        $render->{label_tag},
        process_attrs( $render->{label_attributes} ),
        $render->{label},
        $render->{label_tag},
        ;

    return $html;
}

sub _string_errors {
    my ( $self, $render ) = @_;

    return '' if !$render->{errors};

    my $html = '';

    if ( $render->{error_container_tag} ) {
        $html .= sprintf qq{<%s%s>\n},
            $render->{error_container_tag},
            process_attrs( $render->{error_container_attributes} ),
            ;
    }

    my @error_html;
    for my $error ( @{ $render->{errors} } ) {
        push @error_html, sprintf qq{<%s%s>%s</%s>},
            $render->{error_tag},
            process_attrs( $error->{attributes} ),
            $error->{message},
            $render->{error_tag},
            ;
    }
    $html .= join "\n", @error_html;

    if ( $render->{error_container_tag} ) {
        $html .= sprintf qq{\n</%s>}, $render->{error_container_tag};
    }

    return $html;
}

sub _string_field_end {
    my ( $self, $render ) = @_;

    # field wrapper template - end

    my $html = '';

    if (   defined $render->{label}
        && $render->{label_tag} ne 'legend'
        && $render->{reverse_single} )
    {
        $html .= sprintf "\n%s", $self->_string_label($render);
    }

    if ( defined $render->{comment} ) {
        $html .= sprintf "\n<span%s>\n%s\n</span>",
            process_attrs( $render->{comment_attributes} ),
            $render->{comment},
            ;
    }

    if ( defined $render->{container_tag} ) {
        $html .= sprintf "\n</%s>", $render->{container_tag},;
    }

    if ( defined $render->{javascript} ) {
        $html .= sprintf qq{\n<script type="text/javascript">\n%s\n</script>},
            $render->{javascript},
            ;
    }

    return $html;
}

around clone => sub {
    my $orig = shift;
    my $self = shift;

    my $clone = $self->$orig(@_);

    for my $list ( qw(
        _filters _constraints _inflators _validators _transformers
        _deflators _errors _plugins )
        )
    {
        $clone->$list( [ map { $_->clone } @{ $self->$list } ] );

        map { $_->parent($clone) } @{ $clone->$list };
    }

    $clone->comment_attributes( Clone::clone( $self->comment_attributes ) );
    $clone->container_attributes( Clone::clone( $self->container_attributes ) );
    $clone->label_attributes( Clone::clone( $self->label_attributes ) );

    return $clone;
};

1;

__END__

=head1 NAME

HTML::FormFu::Role::Element::Field - Role for all form-field elements

=head1 DESCRIPTION

Base-class for all form-field elements.

=head1 METHODS

=head2 default

Set the form-field's default value.

Is an L<output accessor|HTML::FormFu/OUTPUT ACCESSORS>.

=head2 value

For most fields, L</value> is an alias for L</default>.

For the L<HTML::FormFu::Element::Checkbox> and 
L<HTML::FormFu::Element::Radio> elements, L</value> sets what the value of 
the field will be if it is checked or selected. If the L</default> is the 
same as the L</value>, then the field will be checked or selected when 
rendered.

For the L<HTML::FormFu::Element::Radiogroup> and 
L<HTML::FormFu::Element::Select> elements, the L</value> is ignored: 
L<values|HTML::FormFu::Role::Element::Group/values> or 
L<options|HTML::FormFu::Role::Element::Group/options> provides the equivalent 
function.

Is an L<output accessor|HTML::FormFu/OUTPUT ACCESSORS>.

=head2 non_param

Arguments: bool

Default Value: false

If true, values for this field are never returned by L<HTML::FormFu/params>, 
L<HTML::FormFu/param> and L<HTML::FormFu/valid>.

This is useful for Submit buttons, when you only use its value as an 
L<indicator|HTML::FormFu/indicator>

=head2 placeholder

Sets the HTML5 attribute C<placeholder> to the specified value.

Is an L<output accessor|HTML::FormFu/OUTPUT ACCESSORS>.

=head2 javascript

Arguments: [$javascript]

If set, the contents will be rendered within a C<script> tag, within the 
field's container.

=head2 retain_default

If L</retain_default> is true and the form was submitted, but the field 
didn't have a value submitted, then when the form is redisplayed to the user 
the field will have its value set to its default value, rather than the 
usual behaviour of having an empty value.

Default Value: C<false>

=head2 force_default

If L</force_default> is true and the form was submitted, and the field
has a default/value set, then when the form is redisplayed to the user
the field will have its value set to its default value.

If the default value is being changed after FormFu->process is being called
the later default value is respected for rendering, *but* nevertheless the
input value doesn't respect that, it will remain the first value.

Default Value: C<false>

=head2 default_empty_value

Designed for use by Checkbox fields. Normally if a checkbox is not checked,
no value is submitted for that field. If C<default_empty_value> is true,
the Checkbox field is given an empty value during
L<process|HTML::FormFu/process>. Please note that, with this setting,
the checkbox gets an EMPTY value (as opposed to no value at all without
enabling it), NOT the default value assigned to the element (if any).

Default Value: C<false>

=head2 repeatable_count

Only available for fields attached to a
L<Repeatable|HTML::FormFu::Element::Repeatable> element, after
L<< $repeatable->repeat($count) | HTML::FormFu::Element::Repeatable/repeat >>
has been called.

The value is inherited from
L<HTML::FormFu::Element::Repeatable/repeatable_count>.

=head2 clone

See L<HTML::FormFu/clone> for details.

=head2 deflators

See L<HTML::FormFu/deflators> for details.

=head2 deflator

See L<HTML::FormFu/deflator> for details.

=head2 auto_datalist_id

Arguments: [$string]

If any L<Input|HTML::FormFu::Role::Element::Input> element had a datalist,
but does not have L<HTML::FormFu::Role::Element::Input/datalist_id> set,
L</auto_datalist_id> is used to generate the datalist id.

The following character substitution will be performed: C<%f> will be
replaced by L<< $form->id|/id >>, C<%n> will be replaced by
L<< $field->name|HTML::FormFu::Element/name >>, C<%r> will be replaced by
L<< $block->repeatable_count|HTML::FormFu::Element::Repeatable/repeatable_count >>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head1 FORM LOGIC AND VALIDATION

=head2 filters

See L<HTML::FormFu/filters> for details.

=head2 filter

See L<HTML::FormFu/filter> for details.

=head2 constraints

See L<HTML::FormFu/constraints> for details.

=head2 constraint

See L<HTML::FormFu/constraint> for details.

=head2 inflators

See L<HTML::FormFu/inflators> for details.

=head2 inflator

See L<HTML::FormFu/inflator> for details.

=head2 validators

See L<HTML::FormFu/validators> for details.

=head2 validator

See L<HTML::FormFu/validator> for details.

=head2 transformers

See L<HTML::FormFu/transformers> for details.

=head2 transformer

See L<HTML::FormFu/transformer> for details.

=head1 CUSTOMIZING GENERATED MARKUP

Each field is, by default, wrapped in a container.
Each container may also contain a label, a comment, and after an invalid
submission may contain 1 or more error messages.

Example of generated form:

    1   <form action="" method="post">
    2       <div class="has-errors">    # container
    3           <ul class="errors">     # error container
    4               <li>                # error message
    5                   This field must contain an email address
    6               </li>
    7           </li>
    8           <label>Foo</label>      # label
    9           <input name="foo" type="text" value="example.com" />
    10          <span class="comment">  # comment
    11              This is Foo
    12          </span>
    13      </div>
    14  </form>

    # Line 2 starts the 'container' - by default a DIV.
    # Line 2 starts an error container, which may contain 1 or more error
             messages - in this case, a unordered list (UL).
    # Line 4 starts a single error message - in this case, a list item (LI).
    # Line 8 shows a 'label'.
    # Line 9 shows the field's 'input' tag.
    # Lines 10 starts a 'comment'.

To re-order the various parts of each form (label, input, errors, etc) and
arbitrary extra tags, see the L<layout|/layout> method.

=head2 CONTAINER

=head3 container_tag

Default value: 'div'

The container wrapping each entire field, any label, comment, and errors.

=head3 container_attributes

Attributes added to the container tag.

Is an L<attribute accessor|HTML::FormFu/ATTRIBUTE ACCESSOR>.

=head3 auto_container_class

Default Value: '%t'

If set, then the container of each field will be given a class-name based on
the given pattern.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_container_label_class

Default Value: 'label'

If set, and if the field has a L<label|/label>, the container will be given a
class-name based on the given pattern.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_container_comment_class

Default Value: '%t'

If set, and if the field has a
L<comment|HTML::FormFu::Role::Element::Field/comment>, the container will be
given a class-name based on the given pattern.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_container_error_class

Default Value: 'error'

If set, then the container of each field with an error will be given a
class-name based on the given pattern.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_container_per_error_class

Default Value: 'error_%s_%t'

If set, then the container of each field with an error will be given a
class-name based on the given pattern.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>, C<%s>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head2 FORM FIELD

=head3 auto_id

If set, then the field will be given an L<id|HTML::FormFu::Element/id>
attribute, if it doesn't have one already.

E.g., setting C<< $form->auto_id('%n') >> will make each field have an ID
the same as the field's name. This makes our form config simpler, and ensures
we don't need to manually update IDs if any field names are changed.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%r>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head2 LABEL

=head3 label

Set a label to communicate the purpose of the form-field to the user.

Is an L<output accessor|HTML::FormFu/OUTPUT ACCESSORS>.

=head3 auto_label

If L<label|/label> isn't already set, the value of L</auto_label> is passed through
L<localize|HTML::FormFu/localize> to generate a label.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>.

The generated string will be passed to L</localize> to create the label.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 label_tag

Default value: 'label'
(except L<Checkboxgroup|HTML::FormFu::Element::Checkboxgroup>)

Default value: 'legend'
(only L<Checkboxgroup|HTML::FormFu::Element::Checkboxgroup>)

Set which tag is used to wrap a L<label|/label>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 label_attributes

Attributes added to the label container.

Is an L<attribute accessor|HTML::FormFu/ATTRIBUTE ACCESSOR>.

=head2 COMMENT

=head3 comment

Set a comment to be displayed along with the form-field.

Is an L<output accessor|HTML::FormFu/OUTPUT ACCESSORS>.

=head3 comment_attributes

Attributes added to the comment container.

Is an L<attribute accessor|HTML::FormFu/ATTRIBUTE ACCESSOR>.

=head3 auto_comment_class

Default Value: '%t'

If set, and if the field has a
L<comment|HTML::FormFu::Role::Element::Field/comment>, the comment tag will
be given a class-name based on the given pattern.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head2 ERROR CONTAINER

=head3 error_container_tag

If set, and if the field has any errors, a container of this type is
wrapped around all of the field error messages.

    # Example - this would wrap each individual error in a 'li' tag,
    # with a single 'ul' tag wrapped around all the errors.
    
    element:
      name: foo
      error_container_tag: ul
      error_tag: li

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_error_container_class

Add a class-name to the error container.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_error_container_per_error_class

Add a class-name to the error container for each error on that field.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>, C<%s>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head2 ERROR MESSAGES

=head3 error_tag

Default value: 'span'

Sets the tag used to wrap each individual error message.

Defaults to C<span>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.


=head3 auto_error_message

Default Value: 'form_%s_%t'

If set, then each error will be given an auto-generated
L<message|HTML::FormFu::Exception::Input/message>, if it doesn't have one
already.

The generated string will be passed to L</localize> to create the message.

For example, a L<Required constraint|HTML::FormFu::Constraint::Required>
will return the string C<form_constraint_required>. Under the default
localization behaviour, the appropriate message for
C<form_constraint_required> will be used from the default I18N package.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>, C<%s>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 error_attributes

Set attributes on the tag of each error message.

Is an L<attribute accessor|HTML::FormFu/ATTRIBUTE ACCESSOR>.

=head3 auto_error_class

Default Value: 'error_%s_%t'

Add a class-name to the tag of each error message.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>, C<%s>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head2 PROCESSOR CLASSES

=head3 auto_constraint_class

Add a class-name to the container tag, for each constraint added to the field.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_inflator_class

Add a class-name to the container tag, for each inflator added to the field.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_validator_class

Add a class-name to the container tag, for each validator added to the field.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head3 auto_transformer_class

Add a class-name to the container tag, for each transformer added to the field.

Supports L<substitutions|HTML::FormFu/ATTRIBUTE SUBSTITUTIONS>: C<%f>, C<%n>, C<%t>.

Is an L<inheriting accessor|HTML::FormFu/INHERITING ACCESSORS>.

=head2 REORDERING FIELD COMPONENTS

=head2 layout

Specify the order that each sub-part of the element should appear in the
rendered markup.

    # Default Value
    $element->layout( [
        'errors',
        'label',
        'field',
        'comment',
        'javascript',
    ] );

Example: Move the form field (the input tag or equivalent) inside the label
tag, after the label text.
Remove the comment - this will now never be rendered.

    # YAML config
    layout:
      - errors
      - label:
          - label_text
          - field
      - javascript
    
    # prettified example of rendered markup
    <div>
        <span>This field is required.</span>
        <label>
            Foo
            <input name="foo" type="text" />
        </label>
    </div>

Example: Don't wrap the label text inside it's usual tag.
Insert the form field (the input tag or equivalent) inside an arbitrary
extra tag.

    # YAML config
    layout:
      - errors
      - label_text
      - 
        div:
          attributes:
            class: xxx
          content: field
      - comment
      - javascript
    
    # prettified example of rendered markup
    <div>
        <span>This field is required.</span>
        Foo
        <div class="xxx">
            <input name="foo" type="text" />
        </div>
    </div>

The following elements override the default L<layout> value:

=over

=item L<HTML::FormFu::Element::Checkboxgroup|HTML::FormFu::Element::Checkboxgroup>

=item L<HTML::FormFu::Element::Hidden|HTML::FormFu::Element::Hidden>

=back

=head3 Specification

The L<layout|/layout> method accepts an array-ref, hash-ref, or string
argument.

The processing is recursive, so each item in an array-ref may be any value
accepted by the L<layout|/layout> method.

A hash-ref must contain a single key and value pair.
If the hash key is the string C<label>, it creates a C<label> tag, using any
previously defined L<LABEL|/LABEL> customizations.
This allows the label tag to contains other elements, such as the form field.

All other hash key values are asssumed to be an arbitrary block tag name.
The value must be a hash-ref, and may contain one or both C<attributes> or
C<content> keys.

Any C<attributes> value must be a hash-ref, whose key/values are added to
the block tag. No processing or expansion is done to the C<attributes>
hash-ref at all.

The C<content> value may be anything accepted by the L<layout|/layout>
method.

The following strings are accepted:

=over

=item errors

Renders the element error messages.

See L<ERROR CONTAINER|/"ERROR CONTAINER"> and
L<ERROR MESSAGES|/"ERROR MESSAGES"> to customize the tags and attributes.

=item label

Renders the element L<label|/label>.

See L<LABEL|/LABEL> to customize the tag and attributes.

=item label_text

Renders the element L<label|/label> text, without the usual 
L<label_tag|/label_tag>.

=item field

Renders the form field control (an input tag, button, or other control).

=item comment

Renders the element L<comment|/comment>.

See L<COMMENT|/COMMENT> to customize the tag and attributes.

=item javascript

Renders a C<script> tag containing any L<javascript|/javascript>.

=back

=head2 multi_layout

Specify the order that each sub-part of each element within a 
L<HTML::FormFu::Element::Multi|HTML::FormFu::Element::Multi> should
appear in the rendered markup.

    # Default Value
    $element->multi_layout( [
        'label',
        'field',
    ] );

Example: Swap the label/field order. This is equivalent to the 
now-deprecated L<reverse_multi|/reverse_multi> method.

    # YAML config
    multi_layout:
      - field
      - label

The following elements override the default C<multi_layout> value:

=over

=item L<HTML::FormFu::Element::Checkbox|HTML::FormFu::Element::Checkbox>

=back

=head1 RENDERING

=head2 field_filename

The template filename to be used for just the form field - not including the 
display of any container, label, errors, etc. 

Must be set by more specific field classes.

=head2 label_filename

The template filename to be used to render the label.

Defaults to C<label>.

=head1 ERROR HANDLING

=head2 get_errors

See L<HTML::FormFu/get_errors> for details.

=head2 add_error

=head2 clear_errors

See L<HTML::FormFu/clear_errors> for details.

=head1 INTROSPECTION

=head2 get_deflators

See L<HTML::FormFu/get_deflators> for details.

=head2 get_deflator

See L<HTML::FormFu/get_deflator> for details.

=head2 get_filters

See L<HTML::FormFu/get_filters> for details.

=head2 get_filter

See L<HTML::FormFu/get_filter> for details.

=head2 get_constraints

See L<HTML::FormFu/get_constraints> for details.

=head2 get_constraint

See L<HTML::FormFu/get_constraint> for details.

=head2 get_inflators

See L<HTML::FormFu/get_inflators> for details.

=head2 get_inflator

See L<HTML::FormFu/get_inflator> for details.

=head2 get_validators

See L<HTML::FormFu/get_validators> for details.

=head2 get_validator

See L<HTML::FormFu/get_validator> for details.

=head2 get_transformers

See L<HTML::FormFu/get_transformers> for details.

=head2 get_transformer

See L<HTML::FormFu/get_transformer> for details.

=head2 get_errors

See L<HTML::FormFu/get_errors> for details.

=head2 clear_errors

See L<HTML::FormFu/clear_errors> for details.

=head1 DEPRECATED METHODS

=over

=item reverse_single

See L<layout|/layout> instead.

=item reverse_multi

See L<multi_layout|/multi_layout> instead.

=item errors_filename

See L<layout_errors_filename|/layout_errors_filename> instead.

=back

=head1 SEE ALSO

Base-class for L<HTML::FormFu::Role::Element::Group>, 
L<HTML::FormFu::Role::Element::Input>, 
L<HTML::FormFu::Element::Multi>, 
L<HTML::FormFu::Element::ContentButton>, 
L<HTML::FormFu::Element::Textarea>.

Is a sub-class of, and inherits methods from L<HTML::FormFu::Element>

L<HTML::FormFu>

=head1 AUTHOR

Carl Franks, C<cfranks@cpan.org>

=head1 LICENSE

This library is free software, you can redistribute it and/or modify it under
the same terms as Perl itself.

=cut