package RTSoap ;

use lib ( "/opt/rt3/lib", "/opt/rt3/local/lib" );
use RT;
use RT::Ticket;
use RT::Users;
CleanEnv;
RT::LoadConfig;
RT::Init;
our @ISA = qw( SOAP::Server::Parameters );

sub new {
        $self = shift;
        my $class = ref($self) || $self;
        bless {_tic => shift} => $class;
        return $class;
}

sub Hello {
        ### test function ##is soap lite working
        my $self = shift;
        my ($string) = @_;
        return "Hello " . $string;
}

sub RT_User {
        my ($address) = shift;
        unless ($address) {
                return (undef);
        }
        my $user = RT::CurrentUser->new();
        $user->LoadByEmail($address);
        unless ($user->Id){
                return undef;
        }
        return $user;
}

sub GetTicketsByRequestor {
        #### you get a requester and may get status resolved
        ## if you get status = resolved only return a list of resolved tickets else return all non resolved tickets for this requestor

        my $self = shift;
        my %args = %{pop->method};
        my $requestor = $args{'Requester'};
        my $status = $args{'Status'};
        my $error = undef;

        ## Get user
        my $CurrentUser = RT_User($requestor);
        if (!$CurrentUser) {
                $error = "Not RT user, verify email address";
                die $error;
        }
        $RT::Logger->error("Web service invoked do I get back here $requestor");
        my $tickets = new RT::Tickets($CurrentUser);
        if (!$tickets) {
                $error = "No tickets of this status for this user";
                die $error;
        }
        my @collection;
        $tickets->LimitWatcher(TYPE => 'Requestor', VALUE =>$requestor);
        if ($status =~ /resolved/) {
                $tickets->LimitStatus(VALUE => "resolved");
                $tickets->LimitStatus(VALUE => "completed");
        } else {
                $tickets->LimitStatus(VALUE => "open");
                $tickets->LimitStatus(VALUE => "new");
                $tickets->LimitStatus(VALUE => "stalled");
                $tickets->LimitStatus(VALUE => "re-opened");
                $tickets->LimitStatus(VALUE => "monitored");
        }
        $tickets->OrderBy(FIELD => 'id', ORDER => 'DESC');
        while (my $ticket = $tickets->Next) {
                my @list;
                @list = (
                        SOAP::Data->name("TicketParams" => \SOAP::Data->value(
                                SOAP::Data->name('TicketId')->value($ticket->Id()),
                                SOAP::Data->name('Subject')->value($ticket->Subject()),
                                SOAP::Data->name('Status')->value($ticket->Status())))
                );
                push @collection,@list
        }
        if (!@collection) {
                $error = "Failed to retrieve ticket list ";
                die $error;
        }
        return (
                SOAP::Data->name("TicketsList" => \SOAP::Data->value(
                        SOAP::Data->name('CallItWhatEver')->value(@collection)))
        );

}

sub GetTicket(){
        ### you get a ticket id return the ticket providing the supplied requestor is in this ticket requesters string
        use RT::Transactions;
        my $self = shift;
        my %args = %{pop->method};
        my $requestor = $args{'Requester'};
        my $ticketId = $args{'TicketId'};
        my $error = undef;
### debug
#       $RT::Logger->error("Web service invoked and my requestor is $requestor");
#####
        my @collection;
        my $CurrentUser = RT_User($requestor);
        if (!$CurrentUser) {
                $error = "Not RT user, verify email address";
                die $error;
        }
        my $ticket = new RT::Ticket($CurrentUser,$self->{_tic});
        $ticket->Load($ticketId);
        unless ( $ticket->id ) {
                $error = "Error loading ticket, maybe invalid ticket id" ;
                die $error;
        }
        if ($ticket->Id()){
                unless ($ticket->IsWatcher(Type => 'Requestor', PrincipalId => $CurrentUser->PrincipalId)) {
                        $error = "Permission denied. $requestor is not a requestor for this ticket";
                        die $error;
                }
                $Tid = $ticket->Id();
                $TSubject = $ticket->Subject();
                $TStatus = $ticket->Status();
                $TRequestors = $ticket->Requestors->MemberEmailAddressesAsString;
                $TLastUpdate = $ticket->LastUpdated;
                $TResolved = $ticket->Resolved;
                my $trans = RT::Transactions->new($RT::SystemUser);
                $trans->LimitToTicket($Tid);
                $trans->Limit(
                        FIELD    => 'Type',
                        OPERATOR => '=',
                        VALUE    => "Correspond"
                   );
                   $trans->Limit(
                        FIELD    => 'Type',
                        OPERATOR => '=',
                        VALUE    => "Create"
                   );
                while (my $tran = $trans->Next ) {
                        my $attachments = RT::Attachments->new($RT::SystemUser);
                        $attachments->Limit(FIELD    => 'TransactionId',
                                            OPERATOR => '=',
                                            VALUE    => $tran->Id()
                        );
                        $attachments->Limit(FIELD    => 'ContentType',
                                        OPERATOR => '=',
                                        VALUE    => 'text/plain'
                        );
                        $attachments->Limit(FIELD    => 'Content',
                                        OPERATOR => '!=',
                                        VALUE    => ''
                        );
                        my ($update,@updates) ;
                        while (my $attachment = $attachments->Next) {
                                my $aid = $attachment->Id() ;
                                my $atid = $attachment->TransactionId() ;
                                my $acontent = $attachment->Content();
                                $update = (
                                        SOAP::Data->type('string')->name('Correspondence')->value($acontent)
                                );
                         push @updates,$update ;
                        }
                        my @t = (
                            SOAP::Data->name("Update" => \SOAP::Data->value(
                                        SOAP::Data->type('string')->name('TransactionCreator')->value($tran->CreatorObj->Name),
                                        SOAP::Data->type('string')->name('TransactionCreated')->value($tran->Created),
                                        SOAP::Data->type('complexType')->name('Correspondence')->value(@updates)
                                        ))
                        );
                        push  @collection,@t ;
                }
        } else {
                $error = "Error loading ticket updates";
                die $error;
        }
        # format SOAP::Data Object and return
        return (
                SOAP::Data->name('Basics' => \SOAP::Data->value(
                        SOAP::Data->name('TicketId')->value($Tid),
                        SOAP::Data->name('Subject')->value($TSubject),
                        SOAP::Data->name('Status')->value($TStatus),

                        SOAP::Data->name('LastUpdateTime')->value($TLastUpdate),
                        SOAP::Data->name('ResolvedTime')->value($TResolved),
                        SOAP::Data->name('Requesters')->value($TRequestors))),
                SOAP::Data->name('Updates' => \SOAP::Data->value(
                        SOAP::Data->name('CallItWhatEver')->value(@collection)))
        );
}

sub CreateTicket {
        #### attachments handling is rubbish ... need looking at later 
        use MIME::Entity;
        my $MimeMessage;
        my $self = shift;
        my %args = %{pop->method};
        my $requestor = $args{'Requester'};
        my $cc = $args{'Cc'};
        my $queue = $args{'Queue'};
        my $subject = $args{'Subject'};
        my $txt = $args{'Text'};
        my $attach = $args{'Attachment'};
###### for debug purposes ###
        $RT::Logger->error("SOAPING:do I get text? ($txt)");
        if ($attach) {
                 $RT::Logger->error("SOAPING:I have attachment");
        }

############
        my $CurrentUser = RT_User($requestor);
        if (!$CurrentUser) {
                 $CurrentUser = $RT::SystemUser ; ### we need to create tickets for new users as well
        }

        if ($attach) {
                $MimeMessage = $attach;
        } else {
                $Mime = MIME::Entity->build(
                              From => $requestor,
                              Subject =>$subject,
                              Cc => $cc,
                              Type => 'text/plain',
                              Data => $txt
                        );
                 $MimeMessage = $Mime->stringify();
        }


        my $newticket = new RT::Ticket($CurrentUser);
        my $parser = RT::EmailParser->new();
        $parser->ParseMIMEEntityFromScalar($MimeMessage);
        #$parser->ParseMIMEEntityFromScalar($attach);

        my %create_args = (
                Queue => $queue,
                Requestor => $requestor,
                Cc => $cc,
                Subject => $subject,
                MIMEObj => $parser->Entity
                );

        my ( $id, $Trans, $ErrMsg ) = $newticket->Create(%create_args);
        unless ( $id && $Trans ) {
                die $ErrMsg ;
        }
                    return (SOAP::Data->name('TicketId' => \SOAP::Data->value(
                              SOAP::Data->name('TicketId')->value($id))));
}

sub UpdateTicket {
        ### only update if the supplied requester is the ticket requester 
        ### attachments attchments attachments 
        use MIME::Entity;
        my $MimeMessage;
        my $self = shift;
        my %args = %{pop->method};
        my $txt = $args{'Text'};
        my $attach = $args{'Attachment'};
        my $CurrentUser = RT_User($args{'Requester'});
        my $error = undef;
        if (!$CurrentUser) {
                $error = "Not RT user, verify email address";
                die $error;
        }

        if ($attach && $attach != '') {
                $MimMessage = $attach;
        } else {
                $Mime = MIME::Entity->build(
                              From => $requestor,
                              Subject =>$subject,
                              Cc => $cc,
                              Type => 'text/plain',
                              Data => $txt
                        );
                 $MimeMessage = $Mime->stringify();
        }

        my $ticket = new RT::Ticket($CurrentUser);
        $ticket->Load($args{'TicketId'}) ;
        unless ( $ticket->id ) {
                $error = "Error loading ticket, maybe invalid ticket id";
                die $error;
        }
        unless ($ticket->IsWatcher(Type => 'Requestor', PrincipalId => $CurrentUser->PrincipalId)) {
                        $error = "Permission denied. $requestor is not a requestor for this ticket";
                        die $error;
        }
        my $parser = RT::EmailParser->new();
        $parser->ParseMIMEEntityFromScalar($MimeMessage);
        my ($val,$msg);
        if ( $args{'Status'} && $args{'Status'} ne $ticket->Status ) {
                ( $val, $msg ) = $ticket->SetStatus( $args{'Status'} );
                if ($val == 0) {
                        $msg = "Failed to update status";
                        die $msg;
                }
        }
        if ($MimeMessage) {
                ( $val, $msg ) = $ticket->Correspond( MIMEObj => $parser->Entity,
                                                        CcMessageTo  => $args{'Cc'});
                if ($val == 0) {
                        $msg = "Failed to update ticket";
                        die $msg;
                }
        }
        return (SOAP::Data->name('UpdateStatus')->value("OK"));
}
1;