#------------------------------------------------------------
# Copyright (C) 2006 RoyaltyShare, Inc.   All Rights Reserved
# $Id$
#------------------------------------------------------------
package RPS::MapFace::MapFaceTempMapping;

use strict;
use warnings;
use Data::Dumper;

use lib '/app/tools/data_classes/lib';
use Client::Service;

use lib '/app/tools/rps/lib';
use RPS::DB::Item::MapFaceTempMapping;
use RPS::DB::Item::MapFaceTempMappingCriteria;
use RPS::DB::Item::MapFaceTempMappingHistory;
use RPS::DB::Item::SaleImportError;
use RPS::DB::Item::User;
use RPS::MapFace::MapFaceTempMappingHistoryList;
use RPS::Import::Importer;

use lib '/app/tools/common/lib';
use Common::Assert;
use Common::RSApp;
use Common::Util;
use Common::DB::Item::MapFaceFile;
use Common::DB::Item::MapFaceService;
use Common::DB::Item::Client;
use Common::FormObject;
use base 'Common::FormObject';

sub _init {
    my ( $self, %args ) = @_;

    $self->SUPER::_init(%args);

    my %properties;

    if ( $args{_dbItem} ) {
        $self->_propertiesFromDBItem( \%properties, $args{_dbItem} );
    } else {
        my $fileID       = $args{fileID};
        my $mappingGroup = $args{mappingGroup};
        assert($fileID);
        assert($mappingGroup);

        my $mapFaceTempMapping = RPS::DB::Item::MapFaceTempMapping->GetByFileAndGroup( $fileID, $mappingGroup );
        while ( $mapFaceTempMapping->hasNext() ) {
            my $tempMapping = $mapFaceTempMapping->next();
            $self->_propertiesFromDBItem( \%properties, $tempMapping );
        }
    }

    $self->_initProperties( \%properties );

    return $self;
}

sub _propertiesFromDBItem {
    my ( $self, $hrProperties, $dbItem ) = @_;

    $hrProperties->{mapface_temp_mapping_id} = $dbItem->mapface_temp_mapping_id;
    $hrProperties->{file_id}                 = $dbItem->file_id;
    $hrProperties->{group_num}               = $dbItem->group_num;
    $hrProperties->{service_id}              = $dbItem->service_id;
    $hrProperties->{product_type}            = $dbItem->product_type;
    $hrProperties->{format_type}             = $dbItem->format_type;
    $hrProperties->{media_type}              = $dbItem->media_type;
    $hrProperties->{country_code}            = $dbItem->country_code;
    $hrProperties->{resolving_user_id}       = $dbItem->resolving_user_id;
    $hrProperties->{approving_user_id}       = $dbItem->approving_user_id;
    $hrProperties->{status}                  = $dbItem->status;
}

sub _initProperties {
    my ( $self, $props ) = @_;

    $self->{MapFaceTempMappingID} = Common::FormObject::Scalar->new( value => $props->{mapface_temp_mapping_id}, readOnly => 1 );
    $self->{FileID}               = Common::FormObject::Scalar->new( value => $props->{file_id} );
    $self->{GroupNum}             = Common::FormObject::Scalar->new( value => $props->{group_num} );
    $self->{ServiceID}            = Common::FormObject::Scalar->new( value => $props->{service_id} );
    $self->{ProductType}          = Common::FormObject::Scalar->new( value => $props->{product_type} );
    $self->{FormatType}           = Common::FormObject::Scalar->new( value => $props->{format_type} );
    $self->{MediaType}            = Common::FormObject::Scalar->new( value => $props->{media_type} );
    $self->{CountryCode} = Common::FormObject::Scalar::String->new( value => $props->{country_code} );
    $self->{ResolvingUserID} = Common::FormObject::Scalar->new( value => $props->{resolving_user_id} );
    $self->{ApprovingUserID} = Common::FormObject::Scalar->new( value => $props->{approving_user_id} );
    $self->{Status}          = Common::FormObject::Scalar->new( value => $props->{status} );

    if ( $props->{resolving_user_id} ) {
        my $resolvingUser = RPS::DB::Item::User->Lookup( user_id => $props->{resolving_user_id} );
        $self->{ResolvingUserName} = $resolvingUser->first_name . " " . $resolvingUser->last_name;
    }

    if ( $props->{approving_user_id} ) {
        my $approvingUser = RPS::DB::Item::User->Lookup( user_id => $props->{approving_user_id} );
        $self->{ApprovingUserName} = $approvingUser->first_name . " " . $approvingUser->last_name;
    }

    if ( $props->{mapface_temp_mapping_id} ) {
        $self->{MapFaceTempMappingHistoryList} =
          RPS::MapFace::MapFaceTempMappingHistoryList->new( mapFaceTempMappingID => $props->{mapface_temp_mapping_id} );
    }

    my $serviceName;

    if ( $props->{service_id} ) {
        my $service = RPS::DB::Item::Service->Lookup( service_id => $props->{service_id} );
        if ( !$service ) {
            $service = Common::DB::Item::MapFaceService->Lookup( service_id => $props->{service_id} );
        }
        if ($service) {
            $serviceName = $service->service_name;
        }
    }

    $self->{ServiceName} = Common::FormObject::Scalar::String->new( value => $serviceName );
}

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

    my $valid = 1;

    # Prevent mapping to soundexchange
    if ( $self->ServiceID() == Client::Service::DSP_SOUNDEXCHANGE ) {
        $valid = 0;
        $self->{ServiceID}->setError(Common::FormObject::kErrFieldInvalid);
    }

    return $valid;
}

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

    my $fileID   = $self->FileID();
    my $clientID = Common::RSApp::GetClientID();

    my $dbObj;
    if ( defined $self->MapFaceTempMappingID() ) {
        $dbObj = RPS::DB::Item::MapFaceTempMapping->Lookup( mapface_temp_mapping_id => $self->MapFaceTempMappingID() );
    } else {
        $dbObj = RPS::DB::Item::MapFaceTempMapping->Create();
    }

    # If applicable, we'll need to create the new service now so that we can get the new service id to store.
    if ( !$self->ServiceID() && $self->ServiceName() ) {

        # Let's make sure that we really don't have this service already.
        # If you're quick enough, you can fool the auto-complete into thinking it's
        # a new name when it's not.
        my $serviceID = $self->RPS::Import::Importer::getServiceID( lc( $self->ServiceName() ) );

        # Also need to check mapface_service table in common
        if ( !$serviceID ) {
            my $mapfaceService = Common::DB::Item::MapFaceService->Lookup( service_name => $self->ServiceName() );
            if ( defined $mapfaceService && lc( $mapfaceService->service_name ) eq lc( $self->ServiceName() ) ) {
                $serviceID = $mapfaceService->service_id;
            }
        }

        if ($serviceID) {
            $self->ServiceID($serviceID);
        } else {
            my $serviceObj = Common::DB::Item::MapFaceService->Create( service_name => $self->ServiceName() );
            $serviceObj->service_name_clean( Common::Util::clean_name( $self->ServiceName() ) );
            $serviceObj->save();
            $self->ServiceID( $serviceObj->service_id );
        }
    }

    if ( $self->ServiceID() ) {

        # Also, this may be a regular service that we have in Client::Service,
        # but not in the client's database yet.  In that case,
        # let's add it to the client's database now.
        my $mapfaceService = Common::DB::Item::MapFaceService->Lookup( service_id => $self->ServiceID() );

        if ( !$mapfaceService ) {
            Client::Service::AddService(
                client_id  => $clientID,
                service_id => $self->ServiceID()
            );
        }
    }

    my $userID = Common::RSApp::GetActiveUserID();

    # set fields here
    #
    $dbObj->file_id($fileID);
    $dbObj->group_num( $self->GroupNum() );
    $dbObj->service_id( $self->ServiceID() );
    $dbObj->product_type( $self->ProductType() );
    $dbObj->format_type( $self->FormatType() );
    $dbObj->media_type( $self->MediaType() );
    $dbObj->country_code( $self->CountryCode() );
    $dbObj->status(RPS::DB::Item::MapFaceTempMapping::STATUS_MAPPED);
    $dbObj->resolving_user_id($userID);

    # save db item
    #
    $dbObj->save();

    # reload object
    #
    $self->_init( _dbItem => $dbObj );

    # Now we need to update the remaining_errors field in the mapface_file table in RSCOMMON.
    my $remainingCount = RPS::DB::Item::MapFaceTempMapping->GetRemainingErrorCountByFileID($fileID);
    my $mapFaceFiles = Common::DB::Item::MapFaceFile->GetByClientAndFileID( $clientID, $fileID );
    while ( $mapFaceFiles->hasNext() ) {
        my $mapFaceFile = $mapFaceFiles->next();
        $mapFaceFile->remaining_errors($remainingCount);
        $mapFaceFile->resolving_user_id($userID);

        if ( $remainingCount == 0 ) {
            $mapFaceFile->status(Common::DB::Item::MapFaceFile::STATUS_REVIEW);
        }

        $mapFaceFile->save();
    }

    # And add the event to this history.
    my $newHistoryAction = RPS::DB::Item::MapFaceTempMappingHistory->Create(
        mapface_temp_mapping_id => $self->MapFaceTempMappingID(),
        user_id                 => $userID,
        action                  => RPS::DB::Item::MapFaceTempMappingHistory::kActionMapped,
    );

    $newHistoryAction->save();
}

sub delete {
    my $self = shift;

    # First let's get rid of the mapping criteria.
    RPS::DB::Item::MapFaceTempMappingCriteria->DeleteByMappingID( $self->MapFaceTempMappingID );

    # Next the history
    RPS::DB::Item::MapFaceTempMappingHistory->DeleteByMappingID( $self->MapFaceTempMappingID );

    # And finally delete the mapping itself.
    my $myDBObj = RPS::DB::Item::MapFaceTempMapping->Lookup( mapface_temp_mapping_id => $self->MapFaceTempMappingID() );
    $myDBObj->delete();

    return 1;
}

1;