#! /usr/bin/perl

use strict ;
use warnings ;

use JSON::PP ;
use TS ;

my $DEF_NAME = 'data' ;
my $RE_NAME  = qr{^\w+$} ;
my $MEM = ':memory:' ;

my $prog = substr $0, rindex ( $0, '/' ) + 1 ;
my $Usage = <<USAGE ;
Usage: $prog [OPTIONS] file.ts COMMAND
OPTIONS :
  option v : be verbose
  option q : be quiet
  option d : show debug info
  option f : action ; otherwise dry-run
COMMAND :
  make [-n name] attr ...
  drop [-n name] attr ...
  move [-n name] attr new_name
  save [-n name] [-t time] attr:[val] ...
  dump [-n name] [-j]
  rrdx [-n name] file.rrd
  info [-j]
  open
options :
  option n : use table <name> ; default 'data'
  option t : use stamp <time> ; default 'date +%s' ; like @{[time]}
  option j : read/write as json
-------------------------------------------------------------------
make : adds columns name.attr ; may create file.ts
drop : drops columns name.attr ; drops table name if no columns remain
move : renames column name.attr
save : inserts or updates one row in table name.
       If name.attr doesn't exist, attr:val is ignored.
       If 'val' is empty, attr is set to NULL.
info : lists tables and their columns
dump : dumps rows in table <name> ; default 'data'
open : execs dbish dbi:SQLite:dbname=file.ts \@ARGV
rrdx : drops table <name> ; imports file.rrd into table <name>
-------------------------------------------------------------------
USAGE
sub Usage { die "$_[0]$Usage" ; }
sub Error { die "[error] $prog: $_[0]\n" ; }
sub Warn  { warn "[warn] $prog: $_[0]\n" ; }

# usage: &GetOptions(ARG,ARG,..) defines $opt_ID as 1 or user spec'ed value
# usage: &GetOptions(\%opt,ARG,ARG,..) defines $opt{ID} as 1 or user value
# ARG = 'ID' | 'ID=SPC' | 'ID:SPC' for no-arg, required-arg or optional-arg
# ID  = perl identifier
# SPC = i|f|s for integer, fixedpoint real or string argument

use Getopt::Long ;
Getopt::Long::config ( 'no_ignore_case' ) ;
my %opt = () ; Usage '' unless GetOptions
  ( \%opt, qw(v q d f n=s j t=i) ) ;
Usage("[error] Arg count\n") unless @ARGV >= 1 ;

$opt{v} ||= $opt{d} ;
TS -> set_opts ( \%opt ) ;

my $FILE = shift ;
my $CMD  = shift || 'info' ;
my $NAME = lc $opt{n} || $DEF_NAME ;
my @ATRS = () ;
my @VALS = () ;
my $RRD  = '' ;

if ( $CMD eq 'make' )
  { @ATRS = @ARGV ;
    Usage "[error] Arg count [$CMD]\n" unless @ARGV ;
  }
elsif ( $CMD eq 'drop' )
  { @ATRS = @ARGV ;
    Usage "[error] Arg count [$CMD]\n" unless @ARGV ;
  }
elsif ( $CMD eq 'move' )
  { @ATRS = @ARGV ;
    Usage "[error] Arg count [$CMD]\n" unless @ARGV == 2 ;
  }
elsif ( $CMD eq 'save' )
  { Usage "[error] Arg count [$CMD]\n" unless @ARGV >= 1 ;
    for ( @ARGV )
      { my ( $atr, $val ) = split /:/, $_ ;
        push @ATRS, $atr ;
        push @VALS, $val ;
      }
  }
elsif ( $CMD eq 'rrdx' )
  { Usage "[error] Arg count [$CMD]\n" unless @ARGV == 1 ;
    $RRD = shift ;
  }

$NAME = lc $NAME ;
@ATRS = map lc $_, @ATRS ;

Error "bad name [$NAME]" unless $NAME =~ $RE_NAME ;
for my $atr ( @ATRS ) { Error "bad attr [$atr]" unless $atr =~ $RE_NAME ; }

unless ( $CMD eq 'make' or $CMD eq 'rrdx' or $FILE eq $MEM )
  { Error "can't find file [$FILE]" unless -f $FILE ; }

my $TS = TS -> Make ( file => $FILE ) ;
$TS -> connect or Error "can't connect with $FILE" ;
die unless $TS -> check ;

sub _max
  { return undef unless @_ ;
    my $res = shift ; for ( @_ ) { $res = $_ if $_ > $res ; } $res ;
  }

sub _txt4
  { my $x = shift ;
    return 'UNDEF' unless defined $x ;
    return 'EMPTY' unless length  $x ;
    return $x ;
  }

sub make
  { my $name = shift ;
    my @atrs = @_ ;
    $TS -> add_tab ( $name ) ;
    $TS -> add_col ( $name, $_ ) for sort @atrs ;
  }

sub drop
  { my $name = shift ;
    my @atrs = @_ ;
    $TS -> drop_cols ( $name, @atrs ) ;
  }

sub move
  { my $name = shift ;
    my @atrs = @_ ;
    $TS -> move_col ( $name, @atrs ) ;
  }

sub info
  { my $res  = {} ;
    my $tabs = $TS -> _tabs ;
    for my $tab ( @$tabs )
      { $res -> { $tab } = $TS -> user_cols ( $tab ) ; }
    if ( $opt{j} )
      { print JSON::PP->new->pretty->encode ( $res ) ; }
    else
      { my $W = _max ( map length $_, @$tabs ) || 0 ;
        printf "name %-${W}s : %s\n" , $_, join ' ', @{ $res -> { $_ } }
          for sort @$tabs ;
      }
  }

sub dmpx
  { my $name = shift ;
    my $res  = $TS -> select_all ( $name ) ;
    if ( $opt{j} )
      { print JSON::PP->new->canonical(1)->pretty->encode ( $res ) ; }
    else
      { my @cols = $TS -> user_cols ( $name ) ;
        printf "# %s : %s\n", $name, join ' ', @cols ;
        for my $row ( @$res )
          { my @txt = map { _txt4 $_ } @$row { $TS::TIME, @cols } ;
            printf "%s\n", join ' ', @txt ;
          }
      }
  }

sub save
  { my $name = shift ;
    my $hash = {} ; @$hash { @ATRS } = @VALS ;
    $TS -> save_hash ( $name, $hash, $opt{t} ) ;
  }

sub rrdx
  { my $name = shift ;
    my $file = shift ;
    my ( $nams, $tups ) = @{ $TS -> read_rrd ( $file ) } { qw(nams tups) } ;
    printf "found %d tuples in file $file\n", scalar @$tups ;
    $TS -> del_tab ( $name ) ;
    $TS -> add_tab ( $name ) ;
    $TS -> add_col ( $name, $_ ) for @$nams ;
    my $cnt = $TS -> insert_tups ( $name, $nams, $tups ) ;
    printf "inserted %d tuples into table %s\n", $cnt, $name ;
  }

if ( $CMD eq 'make' )
  { make $NAME, @ATRS ; }
elsif ( $CMD eq 'drop' )
  { drop $NAME, @ATRS ; }
elsif ( $CMD eq 'move' )
  { move $NAME, @ATRS ; }
elsif ( $CMD eq 'info' )
  { info ; }
elsif ( $CMD eq 'dump' )
  { dmpx $NAME ; }
elsif ( $CMD eq 'save' )
  { save $NAME ; }
elsif ( $CMD eq 'open' )
  { exec "dbish dbi:SQLite:dbname=$FILE @ARGV" ; }
elsif ( $CMD eq 'rrdx' )
  { rrdx $NAME, $RRD ; }
else
  { Error "unknown command [$CMD]" ; }

END { $TS -> disconnect if $TS and $TS -> dbh ; }