package RSWS::AssetMgmt;
use strict;

use base 'RSWS';

use constant CMD_SAVE   => 'save';
use constant CMD_STATUS => 'status';

use constant TYPE_IMAGE => 'image';
use constant TYPE_AUDIO => 'audio';

use constant IMAGE_ORIG => 'original';
use constant IMAGE_TH   => 'thumbnail';
use constant IMAGE_MED  => 'large';
use constant IMAGE_DIST => 'distribution';

sub session_id {
    my $self = shift;
    $self->{reqArgs}{session_id} = shift;
}

sub file_name {
    my $self    = shift;
    my $name    = shift;
    my $incFlag = $self->{type} eq TYPE_AUDIO ? 0 : 1;
    return unless length $name;

    $self->_addItemToReq( $incFlag, 'file_name_', $name );

    if ( $self->{type} eq TYPE_IMAGE ) {
        my $size = shift || IMAGE_ORIG;
        $self->_addItemToReq( 0, 'file_type_', $size );
    }

    return 1;
}

sub file_id {
    my $self = shift;
    return unless ( $_[0] =~ /^\d+$/ );

    $self->_addItemToReq( 0, 'file_id_', @_ );

    return 1;
}

sub _init {
    my $self = shift;
    my %args = @_;

    $self->_requestType('post');
    $self->{xmlSimple} = XML::Simple->new();

    my $action = lc $args{action};
    $self->{action} =
        $action eq 'save'   ? CMD_SAVE
      : $action eq 'status' ? CMD_STATUS
      :                       '';
    die "invalid action specified ($action)\n" unless $self->{action};

    my $type = lc $args{media_type};
    $self->{type} =
        $type eq 'image' ? TYPE_IMAGE
      : $type eq 'audio' ? TYPE_AUDIO
      :                    '';
    die "invalid media_type specified ($type)\n" unless $self->{type};

    $self->{host} = $args{host_id} || die "need to specify host_id\n";
    $self->{reqArgs} = {
        client_id => $args{client_id},
        c         => $self->{action},
        type      => $self->{type},
    };
    $self->{itemCount} = 0;
}

sub _requestURL {

    #return 'https://dev02.royaltyshare.com/rsws/assetmgmt'; # for testing
    return 'https://' . $_[0]->{host} . '.royaltyshare.com/rsws/assetmgmt';
}

sub _requestArgs {
    return $_[0]->{reqArgs};
}

sub _responseHandler {
    my $self     = shift;
    my $response = shift;

    return undef unless ( length $response );
    my $dataRef = $self->{xmlSimple}->XMLin($response);
    unless ( ref $dataRef ) {
        $self->error('failed to parse response');
        return undef;
    }

    my $assetInfo = {};
    if ( $self->{action} eq CMD_SAVE ) {
        if ( $self->{type} eq TYPE_IMAGE ) {
            $assetInfo = $dataRef->{Image};
        } else    # audio
        {
            $self->_storeAudioResponse( $dataRef->{Track}, $assetInfo );
        }
    } else    # status - only for audio file types
    {
        $self->_storeAudioResponse( $dataRef->{Track}, $assetInfo );
    }

    $self->response_error_count( $dataRef->{Errors} );
    return $assetInfo;
}

sub _addItemToReq {
    my $self        = shift;
    my $noIncrement = shift;
    my $fileKey     = shift() . $self->{itemCount};

    $self->{reqArgs}{$fileKey} = shift;
    $self->{reqArgs}{item_count} = $self->{itemCount} + 1;
    $self->{itemCount}++ unless $noIncrement;
}

sub _storeAudioResponse {
    my $self     = shift;
    my $response = shift;
    my $audioRef = shift;
    my $keyName  = $self->{action} eq CMD_SAVE ? 'TrackName' : 'MediaFileID';

    if ( ref($response) eq 'ARRAY' ) {
        foreach my $track (@$response) {
            delete $track->{size};
            delete $track->{i};
            my $key = delete $track->{$keyName};
            $audioRef->{$key} = $track;
        }
    } else {
        delete $response->{size};
        delete $response->{i};
        my $key = delete $response->{$keyName};
        $audioRef->{$key} = $response;
    }
}

1;