package Importer;

use strict;
use warnings;
use IO::File;

use lib '/app/tools/common/lib';
use Common::Util qw(trimspaces trimquotes);
use Common::Assert;

# reporting flags and variable
#
use constant kQuiet => 0;
use constant kNormal => 1;
use constant kDebug => 3;

use constant kProgressQuanta => 200;

use constant kTabDelimiter => "\t";

sub new
{
    my ($class, %args) = @_;

    my $self = bless {}, $class;

    return $self->_init(%args);
}

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

    $self->delimiter($args{delimiter} || kTabDelimiter);
    $self->reportLevel($args{report} || kNormal);
    $self->{fieldConfig} = $self->_columns();
    $self->{fieldCount} = scalar @{ $self->{fieldConfig} };

    return $self;
}

# -------------------------------------------------------------
# Subroutines
# -------------------------------------------------------------

sub importFile
{
    my ($self, $inputFilePath) = @_;
    assert($inputFilePath);

    # Open the input file for reading.
    #
    my $inputFile = IO::File->new($inputFilePath) || die "Can't open input file '$inputFilePath': $!\n";

    $self->report("\nImporting file ($inputFilePath)...");

    # skip first line (header row) and start line num at one
    <$inputFile>;
    my $lineNum = 1;
    my $saveCount = 0;
    my $matchCount = 0;
    my $dupCount = 0;
    my $skipCount = 0;
    my $delim = $self->delimiter();

    # Process the file line by line
    #
    while (my $record = <$inputFile>) 
    {
        $lineNum++;

        if (0 == $lineNum % kProgressQuanta)
        {
            $self->report("  record $lineNum ... ");
        }

        # Split the line up into fields.
        #
        chomp $record;
        my @data = split($delim, $record);
        @data = trimquotes(@data);
        @data = _escapequotes(@data);


        # sanity check
        #
        if($#data != $self->{fieldCount})
        {
            #warn "import column count ($self->{fieldCount}) doesn't match data column count (".$#data.") on line $lineNum\n";
        }

        my @fieldValues = ();

        for(my $i=0; $i <= $#data; $i++)
        {
            my $value = $data[$i];

            # do we need to pre-process this data in some way?
            #
            my $preProcess;
            if (exists $self->{fieldConfig}->[$i]->{preProcess})
            {
                my $handler = $self->{fieldConfig}->[$i]->{preProcess};
                $value = $self->$handler($value);
            }
            push(@fieldValues, $value);
        }

        # now that all fields are loaded, check if any adjustment is required
        if ($self->can('post_parse_row'))
        {
            $self->post_parse_row(\@fieldValues);
        }

        # is the data complete?
        #
        if($self->validate(\@fieldValues))
        {
            # have we already created/matched this item?
            #
            if(! $self->found(\@fieldValues))
            {
                # does this item already exist in the system?
                #
                if(! $self->lookup(\@fieldValues))
                {
                    #$self->report("line $lineNum: saved");
                    $self->save(\@fieldValues);
                    $saveCount++;
                }
                else
                {
                    # already exists
                    $self->report("line $lineNum: exists");
                    $matchCount++;
                }
            }
            else
            {
                $self->report("line $lineNum: duplicate");
                $dupCount++;
            }
        }
        else
        {
            $self->report("line $lineNum: skipped");
            $skipCount++;
        }
    }
    my $total = $saveCount+$dupCount+$matchCount+$skipCount;
    $self->report("  Records imported  : $saveCount");
    $self->report("  Records duped     : $dupCount");
    $self->report("  Records matched   : $matchCount");
    $self->report("  Records skipped   : $skipCount");
    $self->report("  ----------------------------");
    $self->report("  Total records     : $total");

    # Done with the input file, close it.
    #
    $inputFile->close();
}

sub found
{
    my ($self, $fieldValues, $itemID) = @_;

    my $key = $self->_getKey($fieldValues);

    if($itemID)
    {
        $self->{_exists}->{$key} = $itemID;
    }

    return $self->{_exists}->{$key};
}

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

    my $valid = 1;

    for(my $i=0; $i <= $self->{fieldCount}; $i++)
    {
        if($self->{fieldConfig}->[$i]->{required} && !length $fieldValues->[$i])
        {
            $valid = 0;
        }
    }

    return $valid;
}

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

    my $fieldValues = $args{dataRow};
    my $class = $args{class};
    my $id = $args{id};

    my %params = ();
    for(my $i=0; $i <= $self->{fieldCount}; $i++)
    {
        next if (! keys %{ $self->{fieldConfig}->[$i] } or $self->{fieldConfig}->[$i]->{no_save});

        my $fieldsAref = $self->{fieldConfig}->[$i]->{saveAs} || [$self->{fieldConfig}->[$i]->{fieldName}];

        foreach my $dbFieldName (@$fieldsAref)
        {
            $params{$dbFieldName} = $fieldValues->[$i];
        }
    }

    my $dbItem = $class->Create(%params);
    $dbItem->save();
    $self->found($fieldValues, $dbItem->$id);
}

sub delimiter
{
    my ($self, $delim) = @_;

    if($delim)
    {
        $self->{_delimiter} = $delim;
    }

    return $self->{_delimiter};
}

sub reportLevel
{
    my ($self, $level) = @_;

    if($level)
    {
        $self->{_reportLevel} = $level;
    }

    return $self->{_reportLevel};
}

sub _getLookups
{
    my ($self, $fieldValues) = @_;

    my @values;
    for(my $i=0; $i <= $self->{fieldCount}; $i++)
    {
        if($self->{fieldConfig}->[$i]->{lookup})
        {
            push @values, $fieldValues->[$i];
        }
    }

    return \@values;
}

sub _getKey
{
    my ($self, $fieldValues) = @_;

    my $key;
    my @vals = ();
    for(my $i=0; $i <= $self->{fieldCount}; $i++)
    {
        if($self->{fieldConfig}->[$i]->{lookup})
        {
            push @vals, $fieldValues->[$i];
        }
    }

    if(@vals)
    {
        $key = join('||', @vals);
    }

    return $key;
}


# ------------------------------------------------------------
# Utilities
# ------------------------------------------------------------

sub _escapequotes
{
    my @string = @_;

    for (@string)
    {
        s/\"\"/"/g;
    }

    return wantarray ? @string : $string[0];
}

sub report
{
    my ($self, $text, $level) = @_;

    $level = kNormal unless $level;

    if ($level <= $self->reportLevel())
    {
        print $text . "\n";
    }
}


###
1;# Play nicely.
###