Jifty::Web::Form::Element - Some item that can be rendered in a form

use warnings;
use strict;

package Jifty::Web::Form::Element;
use Scalar::Util qw/blessed/;

use base qw/Jifty::Object Class::Accessor::Fast/;
use Jifty::JSON;

use constant handlers => qw(
    onclick onchange ondblclick onmousedown onmouseup onmouseover
    onmousemove onmouseout onfocus onblur onkeypress onkeydown
    onkeyup onselect
);

use constant possible_handlers => { map {($_ => 1)} handlers};

sub accessors { handlers, qw(class title key_binding key_binding_label id label tooltip continuation rel) }

__PACKAGE__->mk_accessors(map "_$_", handlers);
__PACKAGE__->mk_accessors(qw(class title key_binding key_binding_label id label tooltip continuation rel) );

sub new {
    my ($class, $args, $other) = @_;
    $args = {%{$args}, %{$other || {}}};
    # force using accessor for onclick init
    my $override = {};
    $override->{$_} = delete $args->{$_}
        for grep {possible_handlers->{$_} and defined $args->{$_}} keys %{$args};

    my $self = $class->SUPER::new($args);

    $self->{handlers_used} = {};
    $self->$_( $override->{$_} ) for keys %{$override};

    return $self;
}

__PACKAGE__->_mk_normalising_accessor($_) for __PACKAGE__->handlers;

sub _mk_normalising_accessor {
    my ($class, $accessor) = @_;
    my $internal_method = "_$accessor";
    no strict 'refs';
    *{$accessor} = sub {
        my $self = shift;
        return $self->{$internal_method} unless @_;

        $self->$internal_method($self->_handler_setup($internal_method, @_));
    };
}

sub _handler_setup {
    my $self = shift;
    my $trigger = shift;

    return $self->$trigger unless @_;
    $trigger =~ s/^_//;
    $self->{handlers_used}{$trigger} = 1;

    my ($arg) = @_;

    $arg = [$arg] unless ref $arg eq 'ARRAY';

    #Normalize arguments as much as possible here, to simplify later
    #processing of them here and in Clickable.
    for my $hook ( @$arg ) {
        next unless ref $hook eq 'HASH';

        # Normalize actions to monikers to prevent circular references,
        # since Jifty::Action caches instances of Jifty::Web::Form::Clickable.
        if ( $hook->{submit} ) {
            $hook->{submit} = [ $hook->{submit} ] unless ref $hook->{submit} eq "ARRAY";

            my @submit_tmp;
            foreach my $submit ( @{$hook->{submit}}) {
                if (!ref($submit)) {
                    push @submit_tmp, $submit;
                } elsif(blessed($submit)) {
                    push @submit_tmp, $submit->moniker;
                } else { # it's a hashref
                    push @submit_tmp, $submit->{'action'}->moniker;
                    $hook->{'action_arguments'}->{ $submit->{'action'}->moniker } = $submit->{'arguments'};
                }

            }

            @{$hook->{submit}} =  @submit_tmp;
        }

        $hook->{args} ||= $hook->{arguments}; # should be able to use 'arguments' and not lose.

        if ( $hook->{args} ) {
            # We're going to pass complex query mapping structures
            # as-is to the server, but we need to make sure we're not
            # trying to pass around Actions, merely their monikers.
            for my $key ( keys %{ $hook->{args} } ) {
                next unless ref $hook->{args}{$key} eq "HASH";
                $hook->{args}{$key}{$_} = $hook->{args}{$key}{$_}->moniker for grep { ref $hook->{args}{$key}{$_} } keys %{ $hook->{args}{$key} };
            }
        } else {
            $hook->{args} = {};
        }

    }

    return $arg;

}

sub handlers_used {
    my $self = shift;
    return keys %{$self->{handlers_used}};
}

sub javascript {
    my $self = shift;
    my %response = $self->javascript_attrs;

    return join "",
           map { qq| $_="| . Jifty->web->escape($response{$_}) . qq|"| }
           sort keys %response;
}

sub _javascript_attrs_structure {
    my $self = shift;
    my %structure;

    my $current_region = Jifty->web->current_region;

    for my $trigger ( $self->handlers_used ) {
        # Walk around the Class::Accessor, for speed
        my $value = $self->{"_$trigger"};
        next unless $value;

        if ( !( $self->handler_allowed($trigger) ) ) {
            $self->log->error(
                      "Handler '$trigger' is not supported for field '"
                    . $self->label
                    . "' with class "
                    . ref $self );
            next;
        }

        my @fragments;
            # if $actions is undef, that means we're submitting _all_ actions in the clickable
            # if $actions is defined but empty, that means we're submitting no actions
            # if $actions is not empty, we're submitting those actions
        my $actions = {};    # Maps actions => disable?
        my $confirm;
        my $beforeclick;
        my $action_arguments = {};
        my $preload_key;

        for my $hook (grep {ref $_ eq "HASH"} (@{$value})) {
            my %args;

            # Submit action
            if ( exists $hook->{submit} ) {
                $actions = undef;
                my $disable_form_on_click = exists $hook->{disable} ? $hook->{disable} : 1;
                # Normalize to 1/0 to pass to JS
                $disable_form_on_click = $disable_form_on_click ? 1 : 0;
                for (@{ $hook->{submit} || [] }) {
                    $actions->{$_} = $disable_form_on_click;
                    $action_arguments->{$_} = $hook->{'action_arguments'}->{$_};
                }

            }

            $hook->{region} ||= Jifty->web->qualified_region;

            # Should we show a javascript confirm message?
            if ($hook->{confirm}) {
                $confirm = $hook->{confirm};
            }

            # Some code usable before onclick
            if ($hook->{beforeclick}) {
                $beforeclick = $hook->{beforeclick};
            }

            # Placement
            if (exists $hook->{append}) {
                @args{qw/mode path/} = ('Bottom', $hook->{append});
                $hook->{element} ||= "#region-".$hook->{region};
            } elsif (exists $hook->{prepend}) {
                @args{qw/mode path/} = ('Top', $hook->{prepend});
                $hook->{element} ||= "#region-".$hook->{region};
            } elsif (exists $hook->{popout}) {
                @args{qw/mode path/} = ('Popout', $hook->{popout});
                $hook->{element} ||= "#region-".$hook->{region};
            } elsif (exists $hook->{replace_with}) {
                if (defined $hook->{replace_with}) {
                    @args{qw/mode path region/} = ('Replace', $hook->{replace_with}, $hook->{region});
                } else {
                    @args{qw/mode region/} = ('Delete', $hook->{region});
                }
            } elsif (exists $hook->{refresh}) {
                my $region = ref $hook->{refresh} ? $hook->{refresh} : Jifty->web->get_region($hook->{refresh});
                if ($region) {
                    @args{qw/mode path region/} = ('Replace', $region->path, $region->qualified_name);
                } else {
                    $self->log->debug("Can't find region ".$hook->{refresh});
                    @args{qw/mode path region/} = ('Replace', undef, $hook->{refresh});
                }
            } elsif ((exists $hook->{refresh_self} and $current_region) or ($current_region and $hook->{args} and %{$hook->{args}})) {
                # If we just pass arguments, treat as a refresh_self
                @args{qw/mode path region/} = ('Replace', $current_region->path, $current_region);
            } elsif (exists $hook->{delete}) {
                @args{qw/mode region/} = ('Delete', $hook->{delete});
            } else {
                # If we're not doing any of the above, skip this one
                next;
            }

            # Qualified name if we have a ref
            $args{region} = $args{region}->qualified_name if ref $args{region};

            # What element we're replacing.
            if ($hook->{element}) {
                $args{element} = ref $hook->{element} ? "#region-".$hook->{element}->qualified_name : $hook->{element};
                $args{region}  = $args{element} =~ /^#region-(\S+)/ ? "$1-".Jifty->web->serial : Jifty->web->serial;
            }

            # Arguments
            $args{args} = $hook->{args};

            # Toggle functionality
            $args{toggle} = 1 if $hook->{toggle};

            # Preloading functionality
            if ($hook->{preload}) {
                $preload_key = $hook->{preload} eq 1
                             ? Jifty->web->serial
                             : $hook->{preload};
            }

            # Effects
            $args{$_} = $hook->{$_} for grep {exists $hook->{$_}} qw/effect effect_args remove_effect remove_effect_args/;

            push @fragments, \%args;
        }

        $structure{$trigger} = {
            value            => $value,
            fragments        => \@fragments,
            actions          => $actions,
            action_arguments => $action_arguments,
            confirm          => $confirm,
            beforeclick      => $beforeclick,
            preload_key      => $preload_key,
        };
    }

    return \%structure;
}

sub javascript_attrs {
    my $self = shift;

    my $structure = $self->_javascript_attrs_structure(@_);
    my %response;

    for my $trigger (keys %$structure) {
        my $trigger_structure = $structure->{$trigger};
        my $fragments = $trigger_structure->{fragments};
        my $actions   = $trigger_structure->{actions};

        my $string = join ";",
                     grep { not ref $_ }
                     @{ $trigger_structure->{value} };

        if ( @$fragments or ( !$actions || %$actions ) ) {
            my $update_json = Jifty::JSON::encode_json({
                    actions      => $actions,
                    action_arguments => $trigger_structure->{action_arguments},
                    fragments    => $fragments,
                    continuation => $self->continuation,
                    preload_key  => $trigger_structure->{preload_key},
                });

            my $update = $trigger eq "onclick" ? "Jifty.c(event,$update_json,this)"
                                               : "Jifty.update($update_json,this);";
            $string .= "return $update";
            $string .= " || true" unless $self->javascript_preempt;
        }

        if ($trigger_structure->{confirm}) {
            my $text = Jifty::JSON::encode_json( $trigger_structure->{confirm} );
            $string = "if(!confirm($text)){ Jifty.stopEvent(event); return false; }" . $string;
        }

        if ($trigger_structure->{beforeclick}) {
           $string = $trigger_structure->{beforeclick} . $string;
        }

        $response{$trigger} = $string;
    }

    return %response;
}

sub javascript_preempt { return 1 };

sub key_binding_javascript {
    my $self  = shift;
    my $key   = $self->key_binding;
    my $label = defined $self->key_binding_label
                    ? $self->key_binding_label
                    : $self->label;
    if ($key) {
        $self->log->warn("Keybinding '@{[uc $key]}' will NOT work because the"
                        ." element ('$label') does not have an ID.")
            if not defined $self->id or not length $self->id;

        return "Jifty.KeyBindings.add("
                . Jifty::JSON::encode_json( uc $key ).","
                . "'click', "
                . Jifty::JSON::encode_json( $self->id ).","
                . Jifty::JSON::encode_json( $label )
                . ");";
    }
}

sub render_key_binding {
    my $self = shift;
    return unless $self->key_binding;
    Jifty->web->out(
        '<script type="text/javascript">' .
        $self->key_binding_javascript.
        "</script>");
    return '';
}

sub handler_allowed {
    my $self = shift;
    my ($handler) = @_;

    return {onchange => 1, 
            onclick => 1, 
            ondblclick => 1, 
            onmousedown => 1,
            onmouseup => 1,
            onmouseover => 1,
            onmousemove => 1,
            onmouseout => 1,
            onfocus => 1,
            onblur => 1,
            onkeypress => 1,
            onkeydown => 1,
            onkeyup => 1
           }->{$handler};

}
 


1;