WebService::Lucene::Document - Object to represent a Lucene Document

    # Create a new document
    $doc = WebService::Lucene::Document->new;

    # add a field
    $doc->add( $field );

package WebService::Lucene::Document;

use strict;
use warnings;

use base qw( WebService::Lucene::Client Class::Accessor::Fast );

use WebService::Lucene::Field;
use WebService::Lucene::XOXOParser;
use XML::Atom::Entry;

__PACKAGE__->mk_accessors( qw( fields_ref base_url title relevance ) );

BEGIN {
    for my $type ( WebService::Lucene::Field->types ) {
        no strict 'refs';
        *{ __PACKAGE__ . "\::add_$type" } = sub {
            shift->add( WebService::Lucene::Field->$type( @_ ) );
            }
    }
}

sub new {
    my $class = shift;
    my $self  = $class->SUPER::new;

    $self->clear_fields;

    return $self;
}

sub create {
    my ( $self ) = @_;
    my $url = $self->base_url;

    $url =~ s{[^/]+/?$}{};

    my $new_url = $self->createEntry( $url, $self->as_entry );
    $self->base_url( $new_url );

    return $self;
}

sub new_from_entry {
    my ( $class, $entry ) = @_;
    my $self = $class->new;

    if ( $entry->link ) {
        $self->base_url( $entry->link->href );
    }

    $self->relevance(
        $entry->get( 'http://a9.com/-/opensearch/extensions/relevance/1.0/', 'score' ) );
    $self->title( $entry->title );
    my $content = $entry->content->body;

    my @properties = WebService::Lucene::XOXOParser->parse( $content );

    if ( @properties and $properties[ 0 ]->{ class } ) {
        for my $property ( @properties ) {
            my %attrs = map { $_ => 1 } split( / /, $property->{ class } );
            my $method
                = 'add_' . WebService::Lucene::Field->get_type( \%attrs );
            $self->$method( map { $property->{ $_ } } qw( name value ) );
        }
    }
    else {
        $self->fields_ref(
            {   $self->title =>
                    [ map { $_->{ name } => $_->{ value } } @properties ]
            }
        );
    }

    return $self;
}

sub add {
    my $self   = shift;
    my $fields = $self->fields_ref;

    while ( my $field = shift ) {
        my $name = $field->name;
        unless ( exists $fields->{ $name } ) {
            $fields->{ $name } = [];
        }
        unless ( $self->can( $name ) ) {
            no strict 'refs';
            *{ ref( $self ) . "\::$name" } = _field_accessor( $name );
        }

        push @{ $fields->{ $name } }, $field;
    }
}

*facets = \&fields;

*get = \&fields;

sub fields {
    my $self      = shift;
    my $name      = shift;
    my $fieldsref = $self->fields_ref;

    if ( $name ) {
        my $fields = $fieldsref->{ $name };
        return () unless defined $fields;
        return wantarray ? @$fields : $fields->[ 0 ];
    }

    return map { @{ $fieldsref->{ $_ } } } keys %$fieldsref;
}

sub clear_fields {
    shift->fields_ref( {} );
}

sub remove_field {
    my $self  = shift;
    my $field = shift;

    {
        no strict 'refs';
        undef *{ ref( $self ) . "\::$field" };
    }

    return delete $self->fields_ref->{ $field };
}

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

    my $entry = XML::Atom::Entry->new;
    $entry->title( $self->title || 'New Entry' );

    my @properties;
    for my $field ( $self->fields ) {
        my $types = $field->get_info;

        push @properties,
            {
            name  => $field->name,
            value => $field->value,
            class => join( ' ', grep { $types->{ $_ } } keys %$types )
            };
    }
    my $xml = WebService::Lucene::XOXOParser->construct( @properties );

    $entry->content( $xml );
    $entry->content->type( 'xhtml' );

    return $entry;

}

sub update {
    my ( $self ) = @_;
    $self->updateEntry( $self->base_url, $self->as_entry );
}

sub delete {
    my ( $self ) = @_;
    $self->deleteEntry( $self->base_url );
}

sub _field_accessor {
    my $name = shift;
    return sub {
        my $self   = shift;
        my $fields = $self->fields_ref->{ $name };

        return unless defined $fields;

        my @values
            = map { $_->value } ( wantarray ? @$fields : $fields->[ 0 ] );
        return wantarray ? @values : $values[ 0 ];
        }
}

1;