package EPrints::Plugin::Screen::REF::Report::REF1::View;

use EPrints::Plugin::Screen::REF::Report;
@ISA = ( 'EPrints::Plugin::Screen::REF::Report' );

use strict;

sub new
{
	my( $class, %params ) = @_;

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

	push @{$self->{actions}}, qw( export );

	return $self;
}

sub can_be_viewed { return 1 };

sub allow_export { shift->can_be_viewed }
sub action_export {}

sub wishes_to_export {
        $_[0]->{session}->param( "export" ) ||
        $_[0]->SUPER::wishes_to_export
}
sub export_mimetype
{
        my( $self ) = @_;
        
	my $plugin = $self->{processor}->{plugin};
        return $self->SUPER::export_mimetype if !defined $plugin;

        return $plugin->param( "mimetype" );
}

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

        my $benchmark = $self->{processor}->{benchmark};
        my $uoa = $self->{processor}->{uoa};

        my $plugin = $self->{processor}->{plugin};
        return $self->SUPER::export if !defined $plugin;

        $plugin->initialise_fh( \*STDOUT );
        $plugin->output_list(
                list => $self->users,
                fh => \*STDOUT,
        );
}

# For REF1, select people with at least one selection
sub users
{
        my( $self ) = @_;

        my $benchmark = $self->{processor}->{benchmark};
        my $uoa = $self->{processor}->{uoa};

        my %userids;

        $benchmark->uoa_selections( $uoa )->map(sub {
                (undef, undef, my $selection) = @_;

                $userids{$selection->value( "user_id" )} = undef;
        });

        my $list = $self->{session}->dataset( "user" )->list( [keys %userids] );
        $list = $list->reorder( "name" );

        return $list;
}

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

	$self->SUPER::properties_from;
	
	$self->{processor}->{uoa} = $self->current_uoa;

	my $format = $self->{session}->param( "export" );
	if( $format )
	{
		my $plugin = $self->{session}->plugin( "Export::$format" );
		if( defined $plugin && $plugin->can_accept( "list/user" ) )
		{
			$self->{processor}->{plugin} = $plugin;
		}
	}
}

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

	my $chunk = $self->{session}->make_doc_fragment;
	$chunk->appendChild( $self->html_phrase( 'title' ) );

	my $uoa = $self->current_uoa;

	if( defined $uoa )
	{
		$chunk->appendChild( $self->{session}->make_text( ": " ) );
		$chunk->appendChild( $uoa->render_description );
	}	

	return $chunk;
}

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

	my $session = $self->{session};
	my $benchmark = $self->{processor}->{benchmark};
	my $uoa = $self->{processor}->{uoa};

	my $chunk = $session->make_doc_fragment;

        $chunk->appendChild( $session->html_phrase( "Plugin/Screen/REF/Report:header",
                benchmark => $self->render_current_benchmark,
                export => $self->render_export_bar
        ) );

	$chunk->appendChild( $self->render_progress_bar );

	my @problems;

        my $table = $chunk->appendChild( $session->make_element( "table",
                style => "display: none;",
                class => "ep_ref_problems"
        ) );

        my $user_ids = $self->users->ids;

        my $json = "[".join(',',@$user_ids)."]";

        $chunk->appendChild( $session->make_javascript( <<"EOJ" ) );
Event.observe(window, 'load', function() {
        new REF_Report({
                ids: $json,
                step: 5,
                prefix: 'user',
                onProblems: function() { \$(\$('user_problems').parentNode).show() }
        }).execute();
});
EOJ

        # to keep things in order we provide a div to populate with the content
        foreach my $user_id (@$user_ids)
        {
                $chunk->appendChild( $session->make_element( "div",
                        id => "user_".$user_id,
                        class => "ref_report_box",
                ) );
        }

        my $thead = $table->appendChild( $session->make_element( "thead" ) );
        my $tr = $thead->appendChild( $session->make_element( "tr" ) );
        my $th;
        $th = $tr->appendChild( $session->make_element( "th" ) );
        $th = $tr->appendChild( $session->make_element( "th" ) );
        $th->appendChild( $session->html_phrase( "datasetname_user" ) );
        $th = $tr->appendChild( $session->make_element( "th" ) );
        $th->appendChild( $session->html_phrase( "history_fieldname_details" ) );

        my $tbody = $table->appendChild( $session->make_element( "tbody",
                id => "user_problems",
        ) );

	return $chunk;
}

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

        my $session = $self->{session};

        $session->dataset( "user" )
        ->list( [$session->param( "user" )] )
        ->map(sub {
                (undef, undef, my $user) = @_;

                return if !defined $user; # odd

                my @problems;

                my $frag = $self->render_user( $user, \@problems );

                print $user->id;
                print "\n--\n";
                print $session->xhtml->to_xhtml( $frag );
                print "\n--\n";
                foreach my $problem (@problems)
                {
                        print $session->xhtml->to_xhtml( $self->render_problem_row( $problem ) );
                }
                print "\n--\n";
        });
}

sub render_user
{
        my( $self, $user, $problems ) = @_;

	my $session = $self->{session};
	my $chunk = $session->make_doc_fragment;

	# User metadata problems (and/or local checks!) - See part 3, section 1 of REF Framework (esp. paragraph 84)
	my @user_problems = $self->validate_user( $user );

	# gather problems together (under one user)
	if( scalar( @user_problems ) )
	{
		my $frag = $session->make_doc_fragment;
		
		my $c = 0;
		for( @user_problems )
		{
			$frag->appendChild( $session->make_element( 'br' ) ) if( $c++ > 0 );
			$frag->appendChild( $_ );
		}

		push @$problems, { user => $user, problem => $frag };
	}

	my $div = $chunk->appendChild( $session->make_element( "div" ) );
	my $link = $div->appendChild( $session->make_element( "a",
		name => $user->value( "username" ),
	) );
	$chunk->appendChild( $user->render_citation( "ref_ref1_report" ) );

	my %uoas;

	return $chunk;
}

sub render_problem_row
{
	my( $self, $problem ) = @_;

        my $session = $self->{session};
        my $benchmark = $self->{processor}->{benchmark};
        my $uoa = $self->{processor}->{uoa};

        my $tr = $session->make_element( "tr" );
        my $td;

        my $link_td = $tr->appendChild( $session->make_element( "td" ) );

        my $users = $problem->{user};
        $users = [$users] if ref($users) ne "ARRAY";
        $td = $tr->appendChild( $session->make_element( "td",
                style => "white-space: nowrap",
        ) );
        foreach my $user (@$users)
        {
                $td->appendChild( $session->make_element( "br" ) )
                        if $td->hasChildNodes;
                $td->appendChild( $user->render_citation_link( "brief" ) );

                $link_td->appendChild( $session->make_text( " " ) )
                        if $link_td->hasChildNodes;
                my $link = $link_td->appendChild( $session->render_link(
                        "#".$user->value( "username" ),
                ) );
                $link->appendChild( $self->html_phrase( "view" ) );
                $link_td->appendChild( $session->make_text( "/" ) );
                $link = $link_td->appendChild( $session->render_link(
                        $self->user_control_url( $user ),
                ) );
                $link->appendChild( $self->html_phrase( "edit" ) );
        }

        $td = $tr->appendChild( $session->make_element( "td" ) );
      	$td->appendChild( $problem->{problem} );

        return $tr;
}

sub user_control_url
{
	my( $self, $user ) = @_;

	my $href = URI->new( $self->{session}->config( "userhome" ) );
	$href->query_form(
		screen => "REF::User::Edit",
		userid => $user->id,
	);

	return $href;
}

sub validate_user
{
	my( $self, $user, $selection, $eprint ) = @_;

	my $f = $self->param( "validate_user" );
	return () if !defined $f;

	my @problems = &$f( @_[1..$#_], $self );

	return @problems;
}

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

        my $session = $self->{session};

        return $session->get_plugins(
                type => "Export",
                can_accept => "list/user",
        );
}


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

        return(
                $self->SUPER::hidden_bits,
                uoa => $self->{processor}->{uoa}->id,
        );
}


1;