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

use strict;
use warnings;
use Data::Dumper;
use lib '/app/tools/common/lib';
use Common::MapFace::MapFaceFile;

use lib '/app/tools/rps/lib';
use RPS::File::File;
use RPS::File::Sale;
use RPS::MapFace::MapFaceTempMapping;
use RPS::MapFace::SaleImportErrorList;
use RPS::CountryList;
use RPS::ServiceList;
use RPS::Product::TypeList;
use RPS::DB::Item::MapFaceTempMapping;
use RPS::DB::Item::MapFaceTempMappingCriteria;
use RPS::DB::Item::SaleImportErrorRawValue;
use RPS::DB::Item::SaleImportFieldMapping;

use Common::FormObject;
use base 'Common::FormObject';

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

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

    my $fileID       = $args{fileID};
    my $mappingGroup = $args{mappingGroup};

    my $file = RPS::File::File->new( file_id => $fileID );
    $self->{File} = $file->GetObjectXML();

    my $clientID = Common::RSApp::GetClientID();

    my $mapFaceFileID = Common::DB::Item::MapFaceFile->GetMapFaceIDByClientAndFileID( $clientID, $fileID );

    $self->{MapFaceFile} = Common::MapFace::MapFaceFile->new( mapface_file_id => $mapFaceFileID );

    $self->{CurrentGroupNum} = $mappingGroup;
    $self->{NextGroupNum}    = RPS::DB::Item::MapFaceTempMapping->GetNextViewableGroupNum( $fileID, $mappingGroup );
    $self->{PrevGroupNum}    = RPS::DB::Item::MapFaceTempMapping->GetPreviousViewableGroupNum( $fileID, $mappingGroup );
    $self->{TotalGroupCount} = RPS::DB::Item::MapFaceTempMapping->GetTotalViewableGroupCount($fileID);

    # Need to look up the actual max group id in sale_import_error
    $self->{MaxGroupNum} = RPS::DB::Item::MapFaceTempMapping->GetMaxGroupNumByFileID($fileID);

    my $tempMappings = RPS::DB::Item::MapFaceTempMapping->GetSortedByFileID($fileID);

    $self->{MapFaceTempMapping} = RPS::MapFace::MapFaceTempMapping->new( fileID => $fileID, mappingGroup => $mappingGroup );

    my $mappingID = $self->{MapFaceTempMapping}->{MapFaceTempMappingID}->_value();

    # So we need to figure out which "page number" we're on.
    # That means sorting the groups and adjusting the group number by
    # ignoring the auto-approved ones.
    my $groupNum = 1;
    while ( $tempMappings->hasNext() ) {
        my $tempMapping = $tempMappings->next;

        # Ignore auto-approved mappings
        if ( $tempMapping->status == RPS::DB::Item::MapFaceTempMapping::STATUS_AUTO_APPROVED ) {
            next();
        }

        if ( $tempMapping->mapface_temp_mapping_id == $mappingID ) {
            $self->{CurrentPage} = $groupNum;
            last();
        }

        $groupNum++;
    }

    my $criteria = RPS::DB::Item::MapFaceTempMappingCriteria->GetAllByMappingID($mappingID);
    while ( $criteria->hasNext() ) {
        my $row   = $criteria->next;
        my $field = $row->field;
        my $value = $row->value;
        $self->{MappingCriteria}{$field} = $value;
    }

    # We only want to display the first five, but we need the full count.
    my $saleIDs = RPS::DB::Item::SaleImportError->GetDistinctSalesByMappingID($mappingID);
    $self->{SaleCount} = $saleIDs->size();

    my $displayCount = 0;
    my $firstSaleID;
    while ( $saleIDs->hasNext() ) {
        my $saleID = $saleIDs->next();
        $saleID = $saleID->sale_id;

        if ( !$firstSaleID ) {
            $firstSaleID = $saleID;
        }

        my $sale = RPS::File::Sale->new( sale_id => $saleID );
        push @{ $self->{SaleGroup}{Sale} }, $sale->GetObjectXML();
        $displayCount++;
        if ( $displayCount == 5 ) {
            last();
        }
    }

    my $headers = RPS::DB::Item::SaleImportFileHeader->GetAllByFileID($fileID);
    while ( $headers->hasNext() ) {
        my $header = $headers->next();
        my $field  = $header->field;
        my $value  = $header->header;
        if ($value) {
            if ( $self->{FileHeaders}{$field} ) {
                $self->{FileHeaders}{$field} .= " / ";
            }
            $self->{FileHeaders}{$field} .= $value;
        }
    }

    my $mappings = RPS::DB::Item::SaleImportFieldMapping->GetAllByFileID($fileID);
    while ( $mappings->hasNext() ) {
        my $mapping = $mappings->next();
        my $field   = $mapping->field;
        my $value   = $mapping->mapping;
        $self->{Mappings}{$field}{$value} = 1;
    }

    $self->{SaleImportErrorList} = RPS::MapFace::SaleImportErrorList->new( sale_id => $firstSaleID );

    $self->{CountryList} = RPS::CountryList->new();
    $self->{ServiceList} = RPS::ServiceList->new( mapface => 1 );

    return $self;
}

sub _propertyIsEditable {
    my ( $self, $propertyName ) = @_;

    # The Product (and contained objects) can be edited.
    #
    if ( $propertyName eq 'MapFaceTempMapping' ) {
        return 1;
    }
    return 0;
}

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

    $self->{MapFaceTempMapping}->save();
}

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

    my $valid = $self->{MapFaceTempMapping}->validate();

    return $valid;
}

###
1;    #
###