# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
#####################################################
#
#  xCAT plugin package to handle various commands that work with the
#     xCAT tables
#
#   Supported commands:
#         nodeadd
#         nodels
#         nodech
#         tabdump
#         tabrestore
#         noderm
#   To be implemented:
#         gettab
#         chtab
#         tabls
#         getnodecfg (?? this doesn't seem much different from gettab)
#         nr
#   These were xCAT 1.2 commands.  Are they still useful in xCAT 1.3?
#         addattr
#         delattr
#         chtype
#
#####################################################
package xCAT_plugin::tabutils;
use xCAT::Table;
use xCAT::Schema;
use Data::Dumper;
use xCAT::NodeRange;
use xCAT::Schema;    #noderm will need to build list of tables..

#use Getopt::Long qw(GetOptionsFromArray);

1;

#some quick aliases to table/value
my %shortnames = (
                  groups => [qw(nodelist groups)],
                  tags   => [qw(nodelist groups)],
                  mgt    => [qw(nodehm mgt)],
                  switch => [qw(switch switch)],
                  );

#####################################################
# Return list of commands handled by this plugin
#####################################################
sub handled_commands
{
    return {
            gettab     => "tabutils",
            tabdump    => "tabutils",
            tabrestore => "tabutils",
            tabch      => "tabutils",
            nodech     => "tabutils",
            nodeadd    => "tabutils",
            noderm     => "tabutils",
            tabls      => "tabutils",
            nodels     => "tabutils",
            getnodecfg => "tabutils",
            addattr    => "tabutils",
            delattr    => "tabutils",
            chtype     => "tabutils",
            nr         => "tabutils",
            tabgrep    => "tabutils"
            };
}

my %usage = (
    nodech =>
      "Usage: nodech <noderange> [table.column=value] [table.column=value] ...",
    nodeadd =>
      "Usage: nodeadd <noderange> [table.column=value] [table.column=value] ...",
    noderm  => "Usage: noderm <noderange>",
    tabdump =>
      "Usage: tabdump <tablename>\n   where <tablename> is one of the following:\n     "
      . join("\n     ", keys %xCAT::Schema::tabspec),
    tabrestore => "Usage: tabrestore <tablename>.csv",
    );

#####################################################
# Process the command
#####################################################
sub gettab
{
    my $req      = shift;
    my $callback = shift;
    my $keyspec  = shift @{$req->{arg}};
    my @keypairs = split /,/, $keyspec;
    my %keyhash;
    foreach (@keypairs)
    {
        (my $key, my $value) = split /=/, $_;
        $keyhash{$key} = $value;
    }
    my %tabhash;
    foreach my $tabvalue (@{$req->{arg}})
    {
        (my $table, my $column) = split /\./, $tabvalue;
        $tabhash{$table}->{$column} = 1;
    }
    foreach my $tabn (keys %tabhash)
    {
        my $tab = xCAT::Table->new($tabn);
        (my $ent) = $tab->getAttribs(\%keyhash, keys %{$tabhash{$tabn}});
        foreach my $coln (keys %{$tabhash{$tabn}})
        {
            $callback->({data => ["$tabn.$coln:" . $ent->{$coln}]});
        }
        $tab->close;
    }
}

sub process_request
{
    use Getopt::Long;
    Getopt::Long::Configure("bundling");
    Getopt::Long::Configure("pass_through");

    my $request  = shift;
    my $callback = shift;
    my $nodes    = $request->{node};
    my $command  = $request->{command}->[0];
    my $args     = $request->{arg};
    unless ($args or $nodes or $request->{data})
    {
        if ($usage{$command})
        {
            $callback->({data => [$usage{$command}]});
            return;
        }
    }

    if ($command eq "nodels")
    {
        return nodels($nodes, $args, $callback, $request->{noderange}->[0]);
    }
    elsif ($command eq "noderm" or $command eq "rmnode")
    {
        return noderm($nodes, $args, $callback);
    }
    elsif ($command eq "nodeadd" or $command eq "addnode")
    {
        return chnode($nodes, $args, $callback, 1);
    }
    elsif ($command eq "nodech" or $command eq "chnode")
    {
        return chnode($nodes, $args, $callback, 0);
    }
    elsif ($command eq "tabrestore")
    {
        return tabrestore($request, $callback);
    }
    elsif ($command eq "tabdump")
    {
        return tabdump($args, $callback);
    }
    elsif ($command eq "gettab")
    {
        return gettab($request, $callback);
    }
    elsif ($command eq "tabgrep")
    {
        return tabgrep($nodes, $callback);
    }
    else
    {
        print "$command not implemented yet\n";
        return (1, "$command not written yet");
    }

}

sub noderm
{
    my $nodes = shift;
    my $args  = shift;
    my $cb    = shift;
    my $VERSION;
    my $HELP;

    sub noderm_usage
    {
        my %rsp;
        $rsp->{data}->[0] = "Usage:";
        $rsp->{data}->[1] = "  noderm [noderange] ";
        $cb->($rsp);
    }

    @ARGV = @{$args};
    if (
        !GetOptions('h|?|help'  => \$HELP,
                    'v|version' => \$VERSION,)
      )
    {
        &noderm_usage;
    }

    # Help
    if ($HELP)
    {
        &noderm_usage;
        return;
    }

    # Version
    if ($VERSION)
    {
        my %rsp;
        $rsp->{data}->[0] = "2.0";
        $cb->($rsp);
        return;
    }
    my @tablist = ("-d");
    foreach (keys %{xCAT::Schema::tabspec})
    {
        if (grep /^node$/, @{$xCAT::Schema::tabspec{$_}->{cols}})
        {
            push @tablist, $_;
        }
    }
    chnode($nodes, \@tablist, $cb, 0);
}

sub tabrestore
{

    #request->{data} is an array of CSV formatted lines
    my $request    = shift;
    my $cb         = shift;
    my $table      = $request->{table}->[0];
    my $linenumber = 1;
    my $tab        = xCAT::Table->new($table, -create => 1, -autocommit => 0);
    unless ($tab)
    {
        $cb->({error => "Unable to open $table"});
        return;
    }
    $tab->delEntries();    #Yes, delete *all* entries
    my $header = shift @{$request->{data}};
    $header =~ s/"//g;     #Strip " from overzealous CSV apps
    $header =~ s/^#//;
    $header =~ s/\s+$//;
    my @colns = split(/,/, $header);
    my $line;
    my $rollback = 0;
  LINE: foreach $line (@{$request->{data}})
    {
        $linenumber++;
        $line =~ s/\s+$//;
        my $origline = $line;    #save for error reporting
        my %record;
        my $col;
        foreach $col (@colns)
        {
            if ($line =~ /^,/ or $line eq "")
            {                    #Match empty, or end of line that is empty
                 #TODO: should we detect when there weren't enough CSV fields on a line to match colums?
                $record{$col} = undef;
                $line =~ s/^,//;
            }
            elsif ($line =~ /^[^,]*"/)
            {    # We have stuff in quotes... pain...
                    #I don't know what I'm doing, so I'll do it a hard way....
                if ($line !~ /^"/)
                {
                    $rollback = 1;
                    $cb->(
                        {
                         error =>
                           "CSV missing opening \" for record with \" characters on line $linenumber, character "
                           . index($origline, $line)
                           . ": $origline"
                        }
                        );
                    next LINE;
                }
                my $offset = 1;
                my $nextchar;
                my $ent;
                while (not defined $ent)
                {
                    $offset = index($line, '"', $offset);
                    $offset++;
                    if ($offset <= 0)
                    {

                        #MALFORMED CSV, request rollback, report an error
                        $rollback = 1;
                        $cb->(
                            {
                             error =>
                               "CSV unmatched \" in record on line $linenumber, character "
                               . index($origline, $line)
                               . ": $origline"
                            }
                            );
                        next LINE;
                    }
                    $nextchar = substr($line, $offset, 1);
                    if ($nextchar eq '"')
                    {
                        $offset++;
                    }
                    elsif ($offset eq length($line) or $nextchar eq ',')
                    {
                        $ent = substr($line, 0, $offset, '');
                        $line =~ s/^,//;
                        chop $ent;
                        $ent = substr($ent, 1);
                        $ent =~ s/""/"/g;
                        $record{$col} = $ent;
                    }
                    else
                    {
                        $cb->(
                            {
                             error =>
                               "CSV unescaped \" in record on line $linenumber, character "
                               . index($origline, $line)
                               . ": $origline"
                            }
                            );
                        $rollback = 1;
                        next LINE;
                    }
                }
            }
            elsif ($line =~ /^([^,]+)/)
            {    #easiest case, no Text::Balanced needed..
                $record{$col} = $1;
                $line =~ s/^([^,]+)(,|$)//;
            }
        }
        if ($line)
        {
            $rollback = 1;
            $cb->(
                  {
                   error =>
                     "Too many fields on line $linenumber: $origline | $line"
                  }
                  );
            next LINE;
        }

        #TODO: check for error from DB and rollback
        my @rc = $tab->setAttribs(\%record, \%record);
        if (not defined($rc[0]))
        {
            $rollback = 1;
            $cb->(
                  {
                       error => "DB error "
                     . $rc[1]
                     . " with line $linenumber: "
                     . $origline
                  }
                  );
        }
    }
    if ($rollback)
    {
        $tab->rollback();
        $tab->close;
        undef $tab;
        return;
    }
    else
    {
        $tab->commit;    #Made it all the way here, commit
    }
}

sub tabdump
{

    #TODO: need to return header for not-yet existing, but schemad tabs
    #TODO: schema defined column order.
    my $args  = shift;
    my $cb    = shift;
    my $table = "";
    foreach (@$args)
    {
        unless (/^-/)
        {
            if ($table)
            {
                return 1;    #TODO: Error, usage
            }
            $table = $_;
        }
    }
    my $tabh = xCAT::Table->new($table);
    my %rsp;
    unless ($tabh)
    {
        if (defined($xCAT::Schema::tabspec{$table}))
        {
            my $header = join ",", @{$xCAT::Schema::tabspec{$table}->{cols}};
            $header = "#" . $header;
            push @{$rsp{data}}, $header;
            $cb->(\%rsp);
            return;
        }
        $cb->({error => "No such table: $table"});
        return 1;
    }
    my $recs = $tabh->getAllEntries();
    my $rec;
    my $firstline = 1;
    unless (@$recs)
    {
        if (defined($xCAT::Schema::tabspec{$table}))
        {
            my $header = join ",", @{$xCAT::Schema::tabspec{$table}->{cols}};
            $header = "#" . $header;
            push @{$rsp{data}}, $header;
            $cb->(\%rsp);
            return;
        }
    }

    foreach $rec (@$recs)
    {
        my $line = '';
        if ($firstline)
        {
            $firstline = 0;
            $line      = join ",", @{$tabh->{colnames}};
            $line      = "#" . $line;
            push @{$rsp{data}}, $line;
            $line = '';
        }
        foreach (@{$tabh->{colnames}})
        {
            $rec->{$_} =~ s/"/""/g;
            if (defined $rec->{$_})
            {
                $line = $line . '"' . $rec->{$_} . '",';
            }
            else
            {
                $line .= ',';
            }
        }
        $line =~ s/,$//;
        $line = $line . $lineappend;
        push @{$rsp{data}}, $line;
    }
    $cb->(\%rsp);
}

sub chnode
{
    my $nodes    = shift;
    my $args     = shift;
    my $callback = shift;
    my $addmode  = shift;
    my $VERSION;
    my $HELP;

    sub nodech_usage
    {
        my %rsp;
        $rsp->{data}->[0] = "Usage:";
        $rsp->{data}->[1] = " nodech <noderange> [table.column=value] [table.column=value] ...\n ";
        $callback->($rsp);
    }

    @ARGV = @{$args};
    if (
        !GetOptions('h|?|help'  => \$HELP,
                    'v|version' => \$VERSION,)
      )
    {
        &nodech_usage;
    }

    # Help
    if ($HELP)
    {
        &nodech_usage;
        return;
    }

    # Version
    if ($VERSION)
    {
        my %rsp;
        $rsp->{data}->[0] = "2.0";
        $callback->($rsp);
        return;
    }
    if ($addmode)
    {
        my $idx = 0;
        foreach my $arg (@$args)
        {
            unless ($arg =~ /^-/)
            {
                $nodes = [noderange($arg, 0)];
                splice(@$args, $idx, 1);
                last;
            }
            $idx++;
        }
        unless ($nodes)
        {
            $callback->({error => "No range to add detected\n"});
            return;
        }
    }
    my $column;
    my $value;
    my $temp;
    my %tables;
    my $tab;
    my $deletemode;

    #No GetOptionsFromArray...
    #GetOptionsFromArray($args,"d|delete" => \$deletemode);
    #print Dumper($deletemode);
    foreach (@$args)
    {
        if (m/^-/)
        {    #A quick and dirty option parser in lieu of lacking Getoptinos
            if (m/^--/)
            {
                if (m/--delete/)
                {
                    $deletemode = 1;
                    next;
                }
                else
                {
                    $callback->(
                            {data => ["ERROR: Malformed argument $_ ignored"]});
                    next;
                }
            }
            else
            {
                if (m/^-d$/)
                {
                    $deletemode = 1;
                    next;
                }
                else
                {
                    $callback->(
                            {data => ["ERROR: Malformed argument $_ ignored"]});
                    next;
                }
            }
        }

        if ($deletemode)
        {
            if (m/[=\.]/)
            {
                $callback->(
                         {data => ["ERROR: . and = not valid in delete mode"]});
                next;
            }
            $tables{$_} = 1;
            next;
        }
        unless (m/=/)
        {
            $callback->({data => ["ERROR: Malformed argument $_ ignored"]});
            next;
        }
        ($temp, $value) = split('=', $_, 2);
        my $op = '=';
        if ($temp =~ /,$/)
        {
            $op = ',=';
            chop($temp);
        }
        elsif ($temp =~ /\^$/)
        {
            $op = '^=';
            chop($temp);
        }

        if ($shortnames{$temp})
        {
            ($table, $column) = @{$shortnames{$temp}};
        }
        else
        {
            ($table, $column) = split('\.', $temp, 2);
        }
        $tables{$table}->{$column} = [$value, $op];
    }
    foreach $tab (keys %tables)
    {
        my $tabhdl = xCAT::Table->new($tab, -create => 1, -autocommit => 0);
        if ($tabhdl)
        {
            foreach (@$nodes)
            {
                if ($deletemode)
                {
                    $tabhdl->delEntries({'node' => $_});
                }
                else
                {

                    #$tabhdl->setNodeAttribs($_,$tables{$tab});
                    my %uhsh;
                    my $node = $_;
                    foreach (keys %{$tables{$tab}})
                    {
                        my $op  = $tables{$tab}->{$_}->[1];
                        my $val = $tables{$tab}->{$_}->[0];
                        my $key = $_;
                        if ($op eq '=')
                        {
                            $uhsh{$key} = $val;
                        }
                        elsif ($op eq ',=')
                        {    #splice assignment
                            my $cent = $tabhdl->getNodeAttribs($node, [$key]);
                            my $curval;
                            if ($cent) { $curval = $cent->{$key}; }
                            if ($curval)
                            {
                                my @vals = split(/,/, $curval);
                                unless (grep /^$val$/, @vals)
                                {
                                    @vals = (@vals, $val);
                                    my $newval = join(',', @vals);
                                    $uhsh{$key} = $newval;
                                }
                            }
                            else
                            {
                                $uhsh{$key} = $val;
                            }
                        }
                        elsif ($op eq '^=')
                        {
                            my $cent = $tabhdl->getNodeAttribs($node, [$key]);
                            my $curval;
                            if ($cent) { $curval = $cent->{$key}; }
                            if ($curval)
                            {
                                my @vals = split(/,/, $curval);
                                if (grep /^$val$/, @vals)
                                {    #only bother if there
                                    @vals = grep(!/^$val$/, @vals);
                                    my $newval = join(',', @vals);
                                    $uhsh{$key} = $newval;
                                }
                            }    #else, what they asked for is the case alredy

                        }
                    }
                    if (keys %uhsh)
                    {

                        my @rc = $tabhdl->setNodeAttribs($node, \%uhsh);
                        if (not defined($rc[0]))
                        {
                            $callback->({error => "DB error " . $rc[1]});
                        }
                    }
                }
            }
            $tabhdl->commit;
        }
        else
        {
            $callback->(
                 {data => ["ERROR: Unable to open table $tab in configuration"]}
                 );
        }
    }
}

sub tabgrep
{
    my $node = shift;
    my @tablist;
    my $callback = shift;

    foreach (keys %{xCAT::Schema::tabspec})
    {
        if (grep /^node$/, @{$xCAT::Schema::tabspec{$_}->{cols}})
        {
            push @tablist, $_;
        }
    }
    foreach (@tablist)
    {
        my $tab = xCAT::Table->new($_);
        if ($tab->getNodeAttribs($node->[0], ["node"]))
        {
            $callback->({data => [$_]});
        }
        $tab->close;
    }

}

#####################################################
#  nodels command
#####################################################
sub nodels
{
    my $nodes     = shift;
    my $args      = shift;
    my $callback  = shift;
    my $noderange = shift;

    my $VERSION;
    my $HELP;

    sub nodels_usage
    {
        my %rsp;
        $rsp->{data}->[0] = "Usage:";
        $rsp->{data}->[1] = "  nodels [-?|-h|--help] ";
        $rsp->{data}->[2] = "  nodels [-v|--version] ";
        $rsp->{data}->[3] = "  nodels [noderange] ";
#####  xcat 1.2 nodels usage:
        #     $rsp->{data}->[1]= "  nodels [noderange] [group|pos|type|rg|install|hm|all]";
        #     $rsp->{data}->[2]= " ";
        #     $rsp->{data}->[3]= "  nodels [noderange] hm.{power|reset|cad|vitals|inv|cons}";
        #     $rsp->{data}->[4]= "                     hm.{bioscons|eventlogs|getmacs|netboot}";
        #     $rsp->{data}->[5]= "                     hm.{eth0|gcons|serialbios|beacon}";
        #     $rsp->{data}->[6]= "                     hm.{bootseq|serialbps|all}";
        #     $rsp->{data}->[7]= " ";
        #     $rsp->{data}->[8]= "  nodels [noderange] rg.{tftp|nfs_install|install_dir|serial}";
        #     $rsp->{data}->[9]= "                     rg.{usenis|install_roll|acct|gm|pbs}";
        #     $rsp->{data}->[10]="                     rg.{access|gpfs|netdevice|prinic|all}";
        $callback->($rsp);
    }

    @ARGV = @{$args};
    if (
        !GetOptions('h|?|help'  => \$HELP,
                    'v|version' => \$VERSION,)
      )
    {
        &nodels_usage;
    }

    # Help
    if ($HELP)
    {
        &nodels_usage;
        return;
    }

    # Version
    if ($VERSION)
    {
        my %rsp;
        $rsp->{data}->[0] = "2.0";
        $callback->($rsp);
        return;
    }

    # TODO -- Parse command arguments
    #  my $opt;
    #  my %attrs;
    #  foreach $opt (@ARGV) {
    #     if ($opt =~ /^group/) {
    #     }
    #  }
    my $argc = @ARGV;

    if (@$nodes > 0 or $noderange)
    { #Make sure that there are zero nodes *and* that a noderange wasn't requested
                    # TODO - gather data for each node
                    #        for now just return the flattened list of nodes)
        my %rsp;    #build up fewer requests, be less chatty
        if ($argc)
        {
            my %tables;
            foreach (@ARGV)
            {
                my $table;
                my $column;
                my $temp = $_;
                if ($shortnames{$temp})
                {
                    ($table, $column) = @{$shortnames{$temp}};
                }
                else
                {
                    ($table, $column) = split('\.', $temp, 2);
                }
                unless (grep /^$column$/, @{$tables{$table}})
                {
                    push @{$tables{$table}},
                      [$column, $temp];    #Mark this as something to get
                }
            }
            my $tab;
            my %noderecs;
            foreach $tab (keys %tables)
            {
                my $tabh = xCAT::Table->new($tab);
                unless ($tabh) { next; }

                #print Dumper($tables{$tab});
                my $node;
                foreach $node (@$nodes)
                {
                    my @cols;
                    my %labels;
                    foreach (@{$tables{$tab}})
                    {
                        push @cols, $_->[0];
                        $labels{$_->[0]} = $_->[1];
                    }
                    my $rec = $tabh->getNodeAttribs($node, \@cols);
                    foreach (keys %$rec)
                    {
                        my %datseg;
                        $datseg{data}->[0]->{desc}     = [$labels{$_}];
                        $datseg{data}->[0]->{contents} = [$rec->{$_}];
                        $datseg{name} = [$node]; #{}->{contents} = [$rec->{$_}];
                        push @{$noderecs{$node}}, \%datseg;
                    }
                }

                #$rsp->{node}->[0]->{data}->[0]->{desc}->[0] = $_;
                #$rsp->{node}->[0]->{data}->[0]->{contents}->[0] = $_;
                $tabh->close();
                undef $tabh;
            }
            foreach (sort (keys %noderecs))
            {
                push @{$rsp->{"node"}}, @{$noderecs{$_}};
            }
        }
        else
        {
            foreach (@$nodes)
            {
                my $noderec;
                $noderec->{name}->[0] = ($_);
                push @{$rsp->{node}}, $noderec;
            }
        }
        $callback->($rsp);
    }
    else
    {

        # no noderange specified on command line, return list of all nodes
        my $nodelisttab;
        if ($nodelisttab = xCAT::Table->new("nodelist"))
        {
            my @attribs = ("node");
            my @ents    = $nodelisttab->getAllAttribs(@attribs);
            foreach (@ents)
            {
                my %rsp;
                if ($_->{node})
                {
                    $rsp->{node}->[0]->{name}->[0] = ($_->{node});

                    #              $rsp->{node}->[0]->{data}->[0]->{contents}->[0]="$_->{node} node contents";
                    #              $rsp->{node}->[0]->{data}->[0]->{desc}->[0]="$_->{node} node desc";
                    $callback->($rsp);
                }
            }
        }
    }

    return 0;
}