package RSSReader::Feed;
use strict;
use RSSReader::Configuration;
use RSSReader::Category;
use RSSReader::Notifier;
use RSSReader::Feed::Message;
use Data::Dumper;

@RSSReader::Feed::ISA = qw( RSSReader::Notifier );

our $_feeds;

sub new {
	my $c = shift;
	my %a = @_;

    	if (exists($_feeds->{$a{id}}->{feed})) { return $_feeds->{$a{id}}->{feed} }
	
	my $config    = RSSReader::Configuration->new();	
	my $feed_info = $config->get_feed(id => $a{id});
	$_feeds->{$a{id}}->{feed} = bless { info => $feed_info, id=>$a{id} }, $c;
			
	return $_feeds->{$a{id}}->{feed};
}

sub create {
	my $c = shift;
	my %a = @_;

	die "I need a category " unless $a{category};
	die "i need a fetch time" unless exists($a{fetch_interval});
	die "I need a Label" unless exists ($a{label});
	die "I need a url" unless exists ($a{url});
	
	$a{url} = "http://".$a{url} unless $a{url} =~ /^http:\/\//i;

	my @f = __PACKAGE__->search(url=>$a{url});
	if (scalar(@f)) {
		$@ = "This feed is already subscribed";
		return undef;
	}

	my $result = RSSReader::Configuration->new()->insert_feed(%a, location=>$a{category}->id());
	return undef unless $result;
	my $s = __PACKAGE__->new(id=>$result);
	return undef unless $s;
	$a{category}->_new_feed( feed=> $s);
	return $s;
}

sub delete {
	my $s = shift;
	my %a = @_;

	$s->notify('feed_deleted_before');
	foreach my $m ( @{$s->messages}) {
		$m->delete;
	}
	$s->notify('feed_deleted');
	$s->location->_feed_deleted( where => $s);
	RSSReader::Configuration->new()->remove_feed(id=>$s->id());
	$s->notify('feed_deleted_after');
	$s->location->_feed_deleted_after( where => $s);
	return 1;
}

sub fetch_failed {
	my $s = shift;

	$s->last_fetched(time());
	$s->{info}->{fetches_failed}++;
	$s->{info}->{fetches_failed_reason} = $_[0];
	$s->notify('feed_fetch_failed');
	return $s->{info}->{fetches_failed};
}

sub fetches_failed {
	my $s = shift;
	return $s->{info}->{fetches_failed};
}
sub fetches_failed_reason {
	my $s = shift;
	return $s->{info}->{fetches_failed_reason};
}

sub fetch_success {
	my $s = shift;

	$s->last_fetched(time());
	$s->{info}->{fetches_failed} = 0;
	delete $s->{info}->{fetches_failed_reason};
	$s->notify('feed_fetch_success');
	return 1;
}

sub last_fetched {
	my $s = shift;
	if ($_[0]) {
		$s->{info}->{last_fetched} = $_[0];
	}
	return $s->{info}->{last_fetched};
}

sub fetch_interval {
	my $s = shift;
        if (defined($_[0])) {
          $s->{info}->{fetch_interval} = $_[0];
          $s->notify('fetch_interval_changed');
        }
	return $s->{info}->{fetch_interval};
}

sub notify_new_messages {
	my $s = shift;
        if (defined($_[0])) {
          $s->{info}->{notify_new_messages} = $_[0];
          $s->notify('notify_new_messages_changed');
        }
	return $s->{info}->{notify_new_messages};
}

sub id {
	my $s = shift;
	return $s->{id};	
}

sub url {
	my $s = shift;
	if ($_[0]) {
	  $_[0] = "http://".$_[0] unless $_[0] =~ /^http:\/\//i;
	  my @f = __PACKAGE__->search(url=>$_[0]);
	  if (scalar(@f)) {
			$@ = "This feed is already subscribed";
			return undef;
	  }
	  $s->{info}->{url} = $_[0];
	  $s->{info}->{last_fetched}=undef;
	  $s->notify('url_changed');
	}
	return $s->{info}->{url};
}

sub validate_rss_url {
	my $s = shift;
	return 'http://feeds.archive.org/validator/check?url='.$s->url;
}

sub image {
	my $s = shift;
	if ($_[0]) {
		$s->{info}->{image} = $_[0];
		$s->notify('image_changed');
	}
	return $s->{info}->{image};
}

sub image_last_fetched {
	my $s = shift;
	if ($_[0]) {
		$s->{info}->{image_last_fetched} = $_[0];
	}
	return $s->{info}->{image_last_fetched};
}


sub source_link {
        my $s = shift;
	#SITE URL
	if ( $_[0] && ($s->{info}->{source_link} ne $_[0]) ) {
	  
	  $s->{info}->{source_link} = $_[0];
	  $s->notify('source_link_changed');
	}
	return $s->{info}->{source_link};
}

sub rss_version {
	my $s = shift;
	if ( $_[0] && ($s->{info}->{rss_version} ne $_[0]) ) {
	  $s->{info}->{rss_version} = $_[0]; 
	  $s->notify('rss_version_changed');
	}
	return $s->{info}->{rss_version};
}

sub extra_info {
        my $s = shift;
	if ($_[0]) {
	  $s->{info}->{extra_info} = $_[0];
	}
	return $s->{info}->{extra_info};
}


sub description {
        my $s = shift;
	if ($_[0]) {
	  $s->{info}->{description} = $_[0];
	  $s->notify('description_changed');
	}
	return $s->{info}->{description};
}

sub label {
	my $s = shift;
	if ($_[0]) {
	  $s->{info}->{label} = $_[0];
	  $s->notify('label_changed');
	}
	return $s->{info}->{label};
}

sub location {
	my $s = shift;

	if ($_[0]) {
		$s->{info}->{location} = $_[0]->id();
	}
	
	return undef unless $s->{info}->{location};
	return RSSReader::Category->new(id=>$s->{info}->{location});	
}

sub move {
        my $s = shift;
        my %a = @_;

        my $from = $s->location;

        $s->notify('feed_moved_before', to=> $a{to}, from=>$from);
	RSSReader->new->notify('feed_moved_before', to=>$a{to}, from=>$from, feed=>$s);
        $s->location($a{to});
	RSSReader->new->notify('feed_moved_after', to=> $a{to}, from=>$from, feed=>$s);
        $s->notify('feed_moved_after', to=> $a{to}, from=>$from);
	RSSReader->new->notify('feed_moved', to=> $a{to}, from=>$from, feed=>$s);
        $s->notify('feed_moved', to=> $a{to}, from=>$from);

	return 1;
}


sub messages {
	my $s = shift;
	return RSSReader::Feed::Message->search_messages(feed=> $s);
}

sub keep_for_n {
    my $s = shift;
    if (defined($_[0])) {
        $s->{info}->{keep_for_n} = $_[0];
    }
    return $s->{info}->{keep_for_n}
}

sub mark_all_read {
	my $s = shift;
	foreach my $msg (@{$s->messages}) {
		$msg->mark_read();
	}
}

sub mark_all_unread {
	my $s = shift;
	foreach my $msg (@{$s->messages}) {
		$msg->mark_unread();
	}
}

sub unread_messages {
	my $s = shift;
	return RSSReader::Feed::Message->search_messages(feed=> $s, read=>0);
}

sub add_message {
	my $s = shift;
	my %a = @_;
	return RSSReader::Feed::Message->create(feed=>$s, @_);
}

sub get_all_feeds {
	my $s = shift;
	my @feeds_to_return = ();
        my $conf = RSSReader::Configuration->new();
        my @ids  = $conf->get_all_feeds_id();

        foreach my $id (@ids) {
                my $feed = __PACKAGE__->new(id=>$id);
                push @feeds_to_return, $feed;
        }

        return wantarray ? @feeds_to_return : \@feeds_to_return;
	
}

sub search { return shift->search_feeds(@_) }

sub search_feeds {
	my $s = shift;
	my %a = @_;
	
	my @feeds_to_return = ();
	
	my $conf = RSSReader::Configuration->new();	
	my @ids  = $conf->get_all_feeds_id();

	foreach my $id (@ids) {
		my $feed = __PACKAGE__->new(id=>$id);
		if ($a{location}) {
			push @feeds_to_return, $feed if $feed->location()->id() eq  $a{location};
		}
		elsif ($a{url}) {
			push @feeds_to_return, $feed if $feed->url() eq  $a{url};
		}
		else {
			push @feeds_to_return, $feed;
		}
	}

	return wantarray ? @feeds_to_return : \@feeds_to_return;
}

sub _message_marked_read {
	my $s = shift;
	my %a = @_;

	$s->location->_message_marked_read( message => $a{message} );
	$s->notify('message_marked_read', message => $a{message});
}

sub _message_marked_unread {
	my $s = shift;
	my %a = @_;

	$s->location->_message_marked_unread( message => $a{message} );
	$s->notify('message_marked_unread', message => $a{message});
}

sub _new_message {
	my $s = shift;
	my %a = @_;

	$s->location->_new_message( message => $a{message} );
	$s->notify('new_message', message => $a{message});
}

sub _message_deleted {
        my $s = shift;
        my %a = @_;

	$s->location->_message_deleted( message => $a{message} );
        $s->notify('message_deleted', message => $a{message});
}

1;