use strict;
package IMPL::Web::TT::Form;

use parent qw(IMPL::Web::TT::Control);

use IMPL::Class::Property;
use IMPL::DOM::Navigator::SchemaNavigator();

__PACKAGE__->PassThroughArgs;

BEGIN {
    public property base => prop_all;
    public property schema => prop_all;
    public property errors => prop_all;
    public property data => prop_all;
    public property state => prop_all;
    public property formResult => prop_all;
}

sub CTOR {
    my ($this) = @_;
    
    if (my $form = $this->formResult) {
        $this->base($form->{formName});
        $this->errors($form->{formErrors});
        $this->data($form->{formData});
        $this->schema($form->{formSchema});
        $this->state($form->{state});
    } else {
    
        $this->base($this->nodeName) unless $this->base;
        
        die new IMPL::InvalidArgumentException('A schema is required for a form',$this->nodeName)
            unless eval { $this->schema->isa( typeof IMPL::DOM::Schema ) };
        
        die new IMPL::InvalidOperationException('Can\'t find a form definition in a schema',$this->nodeName,$this->base)
            unless $this->schema->selectNodes(sub { $_->nodeName eq 'ComplexNode' and $_->name eq $this->base });
    }
            
    $this->errors([]) unless $this->errors;
}

sub fillContents {
    my ($this) = @_;
    
    my $schema = $this->schema->selectSingleNode(sub { $_->nodeName eq 'ComplexNode' and $_->name eq $this->base });
    
    $this->buildContainer(
        $schema,
        $schema,
        $this->data->isComplex ? $this->data : undef,
        $this
    );
}

sub buildContainer {
    my ($this,$schemaSource,$schema,$domNode,$container,$path) = @_;
    
    $path = [@{$path || []},{node => $domNode, schemaSource => $schemaSource}];
    
    $container ||= $this->document->Create($schemaSource->name,'IMPL::Web::TT::Collection');
    
    foreach my $schemaItem ( $schema->content->childNodes ) {
        my $schemaItemSource = $schemaItem;
        
        $schemaItem = $this->schema->resolveType($schemaItem->type)
            if typeof $schemaItem eq typeof IMPL::DOM::Schema::Node;
            
        my @nodesData = $domNode->selectNodes(sub { $_->schemaSource == $schemaItemSource } ) if $domNode;
        
        push @nodesData, undef unless @nodesData;
            
        if ($schemaItem->isa(typeof IMPL::DOM::Schema::ComplexNode) ) {
            $this->appendChild( $this->buildContainer($schemaItemSource,$schemaItem,$_,undef,$path) ) foreach @nodesData;
        } elsif ($schemaItem->isa(typeof IMPL::DOM::Schema::SimpleNode)) {
            $this->appendChild( $this->buildControl($schemaItemSource,$schemaItem,$_,$path) ) foreach @nodesData;
        }
    }
    
    return $container;
}

sub buildControl {
    my ($this,$schemaSource,$schema,$node,$path) = @_;
    
    my @errors;
    
    if ($node) {
        @errors = grep { ($_->Node || $_->Parent) == $node } @{$this->errors}; 
    } else {
        @errors = grep $_->Schema == $schemaSource, @{$this->errors};
    }
    
    return $this->document->CreateControl(
        $schemaSource->name,
        $this->mapType($schemaSource),
        {
            schema => $schema,
            sourceSchema => $schemaSource,
            errors => \@errors,
            data => $node,
            inputType => $schemaSource->nodeProperty('inputType') || $schema->nodeProperty('inputType'),
            nodeValue => $node && $node->nodeValue, # small hack set a non dom class property through
            queryParameter => $this->makeParameterName([@$path,{ node => $node, schemaSource => $schemaSource}])
        }
    );
}

sub mapType {
    my ($this,$schema) = @_;
    
    $schema->nodeProperty('control') ||
    ( $schema->type && $this->schema->resolveType($schema->type)->nodeProperty('control') )
        or die new IMPL::Exception("Unable to get control class for the form element",$schema->path);
}

sub makeParameterName {
    my ($this,$path) = @_;
    
    join '/', map {
        $_->{node} ?
            (
                $_->{node}->nodeProperty('instanceId') ?
                    $_->{node}->nodeName . '['. ']' :
                    $_->{node}->nodeName
            ) :
            (
                $_->{schemaSource}->maxOccur eq 'unbounded' || $_->{schemaSource}->maxOccur > 1 ?
                    $_->{schemaSource}->name . '[0]' :
                    $_->{schemaSource}->name
            ) 
    } @$path;
}

sub makeControlArgs{
    my ($this,$path) = @_;
    
    my $navi = new IMPL::DOM::Navigator::SchemaNavigator($this->schema);
    my @path = ($this->base, split(/\./,$path) ); 
    
    $navi->NavigateName($_) or die new IMPL::InvalidArgumentException(
        "Can't find a definition for an element",
        $_,
        $path,
        $this->element,
    ) foreach @path;
    
    my $schema = $navi->Current;
    my $sourceSchema = $navi->SourceSchemaNode;
    my $queryParameter = join '/', @path;
    shift @path;
    my $node = $this->data ? $this->data->selectSingleNode(@path) : undef;
    
    my @errors;
    
    if ($node) {
        @errors = grep { ($_->Node || $_->Parent) == $node } @{$this->errors}; 
    } else {
        @errors = grep $_->Schema == $sourceSchema, @{$this->errors};
    }
    
    return {
        schema => $schema,
        sourceSchema => $sourceSchema,
        errors => \@errors,
        data => $node,
        nodeValue => $node && $node->nodeValue, # small hack set a non dom class property through
        queryParameter => $queryParameter,
        inputType => $sourceSchema->nodeProperty('inputType') || $schema->nodeProperty('inputType')
    };
}

sub makeContent {
    my ($this,$mappings) = @_;
    
    my $formSchema = $this->schema->selectSingleNode(sub { $_->nodeName eq 'ComplexNode' and $_->name eq $this->base } )
        or die new Exception("Cant find a schema element for the specified form", $this->base);

    my $doc = $this->document;        
    foreach my $itemSchema ( $formSchema->content->childNodes ) {
        my $itemName = $itemSchema->name; 
        if (my $controlClass = $mappings->{$itemName} ) {
            my $contorl = $doc->CreateControl($itemName,$controlClass,$this->makeControlArgs($itemName));
            $this->appendChild($contorl);
        }
    }
    return;
}

sub formErrors {
    my ($this) = @_;
    
    if (my $node = $this->data ) {
        return [
            grep {
                ( $_->Node || $_->Parent) == $node
            } @{$this->errors}
        ];
    } else {
        return [];
    }
}

1;
__END__

=pod

=head1 NAME

C<IMPL::Web::TT::Form> - Форма с элементами

=head1 DESCRIPTION

Является элементом управления, тоесть для своего преобразования ипользует
шаблон 

=cut