package Lemonldap::NG::Cli;

# Required packages

use strict;
use Lemonldap::NG::Common::Conf;

use feature qw (switch);

# Constants

our $VERSION = "0.2";

my $ERRORS =
{
     TOO_FEW_ARGUMENTS  => "Too few arguments",
     UNKNOWN_ACTION     => "Unknown action",
     CONFIG_WRITE_ERROR => "Error while writting the configuration",
     NOT_IMPLEMENTED    => "Not yet implemented",
};

## @cmethod Lemonldap::NG::Cli new ()
# Create a new Lemonldap::NG::Cli object
#
# @return New Lemonldap::NG::Cli object
sub new
{
     my ($class) = @_;

     my $this =
     {
          "confAccess" => Lemonldap::NG::Common::Conf->new ()
     };

     $this->{conf} = $this->{confAccess}->getConf ();

     bless ($this, $class);
     return $this;
}

## @method int saveConf ()
# Save LemonLDAP::NG configuration
#
# @return Configuration identifier.
sub saveConf
{
     my ($self) = @_;
     my $ret = $self->{confAccess}->saveConf ($self->{conf});
     return $ret;
}

## @method int run (array argv)
# Run the application
#
# @param @argv List of arguments of the command line
# @return Exit code
sub run
{
     my ($self, @argv) = @_;

     $self->{argv} = \@argv;
     $self->{argc} = @argv;

     if (!$self->parseCmd ())
     {
          print STDERR $self->getError (), "\n";
          return 1;
     }

     if (!$self->action ())
     {
          print STDERR $self->getError (), "\n";
          return 1;
     }

     if ($self->{action}->{save})
     {
          # Save configuration
          my $cfgNb = $self->saveConf ();

          # If there is no config identifier, then an error occured
          if (!$cfgNb)
          {
               $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR});
               return 0;
          }

          print "Configuration $cfgNb created!\n";
     }

     return 0;
}

## @method bool parseCmd ()
# Parse command line
#
# @return true on success, false otherwise
sub parseCmd
{
     my ($self) = @_;

     # check if there is at least on action specified
     if ($self->{argc} < 1)
     {
          $self->setError ($ERRORS->{TOO_FEW_ARGUMENTS});
          return 0;
     }

     given ($self->{argv}[0])
     {
          ## Variables

          when ("set")
          {
               # set takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $var = $self->{argv}[1];
               my $val = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "set",
                    save => 1,
                    var  => $var,
                    val  => $val,
               };
          }

          when ("unset")
          {
               # unset takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $var = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "unset",
                    save => 1,
                    var  => $var
               };
          }

          when ("get")
          {
               # get takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $var = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "get",
                    save => 0,
                    var  => $var,
               };
          }

          ## Macros

          when ("set-macro")
          {
               # set-macro takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $m_name = $self->{argv}[1];
               my $m_expr = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "set-macro",
                    save => 1,
                    name => $m_name,
                    expr => $m_expr
               };
          }

          when ("unset-macro")
          {
               # unset-macro takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $m_name = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "unset-macro",
                    save => 1,
                    var  => $m_name
               };

          }

          when ("get-macro")
          {
               # get-macro tkaes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $m_name = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "get-macro",
                    save => 0,
                    name => $m_name
               };
          }

          ## Applications

          when ("apps-set-cat")
          {
               # apps-set-cat takes two parameter
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $catid   = $self->{argv}[1];
               my $catname = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "apps-set-cat",
                    save => 1,
                    id   => $catid,
                    name => $catname
               };
          }

          when ("apps-get-cat")
          {
               # apps-get-cat takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $catid = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "apps-get-cat",
                    save => 0,
                    id   => $catid
               };
          }

          when ("apps-add")
          {
               # apps-add takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid = $self->{argv}[1];
               my $catid = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type  => "apps-add",
                    save => 1,
                    appid => $appid,
                    catid => $catid
               };
          }

          when ("apps-set-uri")
          {
               # apps-set-uri takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid  = $self->{argv}[1];
               my $appuri = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "apps-set-uri",
                    save => 1,
                    id   => $appid,
                    uri  => $appuri
               };
          }

          when ("apps-set-name")
          {
               # apps-set-name takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid   = $self->{argv}[1];
               my $appname = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "apps-set-name",
                    save => 1,
                    id   => $appid,
                    name => $appname
               };
          }

          when ("apps-set-desc")
          {
               # apps-set-desc takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid   = $self->{argv}[1];
               my $appdesc = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "apps-set-desc",
                    save => 1,
                    id   => $appid,
                    desc => $appdesc
               };
          }

          when ("apps-set-logo")
          {
               # apps-set-logo takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid   = $self->{argv}[1];
               my $applogo = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "apps-set-logo",
                    save => 1,
                    id   => $appid,
                    logo => $applogo
               };
          }

          when ("apps-set-display")
          {
               # apps-set-display takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid  = $self->{argv}[1];
               my $appdpy = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "apps-set-display",
                    save => 1,
                    id   => $appid,
                    dpy  => $appdpy
               };
          }

          when ("apps-get")
          {
               # apps-get takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "apps-get",
                    save => 0,
                    id   => $appid
               };
          }

          when ("apps-rm")
          {
               # apps-rm takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $appid = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "apps-rm",
                    save => 1,
                    id   => $appid
               };
          }

          ## Rules

          when ("rules-set")
          {
               # rules-set takes 3 parameters
               if ($self->{argc} < 4)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $uri  = $self->{argv}[1];
               my $expr = $self->{argv}[2];
               my $rule = $self->{argv}[3];

               # define action
               $self->{action} =
               {
                    type => "rules-set",
                    save => 1,
                    uri  => $uri,
                    expr => $expr,
                    rule => $rule
               };
          }

          when ("rules-unset")
          {
               # rules-unset takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $uri  = $self->{argv}[1];
               my $expr = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "rules-unset",
                    save => 1,
                    uri  => $uri,
                    expr => $expr
               };
          }

          when ("rules-get")
          {
               # rules-get takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $uri = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "rules-get",
                    save => 0,
                    uri  => $uri
               };
          }

          ## exported variables

          when ("export-var")
          {
               # export-var takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $key = $self->{argv}[1];
               my $val = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type => "export-var",
                    save => 1,
                    key  => $key,
                    val  => $val
               };
          }

          when ("unexport-var")
          {
               # unexport-var takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $key = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "unexport-var",
                    save => 1,
                    key  => $key
               };
          }

          when ("get-exported-vars")
          {
               # get-exported-varis doesn't take any parameter

               # define action
               $self->{action} =
               {
                    type => "get-exported-vars",
                    save => 0
               };
          }

          ## exported headers

          when ("export-header")
          {
               # export-header takes 3 parameters
               if ($self->{argc} < 4)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost  = $self->{argv}[1];
               my $header = $self->{argv}[2];
               my $expr   = $self->{argv}[3];

               # define action
               $self->{action} =
               {
                    type   => "export-header",
                    save   => 1,
                    vhost  => $vhost,
                    header => $header,
                    expr   => $expr
               };
          }

          when ("unexport-header")
          {
               # unexport-header takes two parameter
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost  = $self->{argv}[1];
               my $header = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type   => "unexport-header",
                    save   => 1,
                    vhost  => $vhost,
                    header => $header,
               };
          }

          when ("get-exported-headers")
          {
               # get-exported-header takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type  => "get-exported-headers",
                    save  => 0,
                    vhost => $vhost
               };
          }

          ## virtual host

          when ("vhost-add")
          {
               # vhost-add takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type  => "vhost-add",
                    save  => 1,
                    vhost => $vhost
               };
          }

          when ("vhost-del")
          {
               # vhost-del takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type  => "vhost-del",
                    save  => 1,
                    vhost => $vhost
               };
          }

          when ("vhost-set-port")
          {
               # vhost-set-port takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];
               my $port  = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type  => "vhost-set-port",
                    save  => 1,
                    vhost => $vhost,
                    port  => $port
               };
          }

          when ("vhost-set-https")
          {
               # vhost-set-https takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];
               my $https = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type  => "vhost-set-https",
                    save  => 1,
                    vhost => $vhost,
                    https => $https
               };
          }


          when ("vhost-set-maintenance")
          {
               # vhost-set-maintenance takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];
               my $off   = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type  => "vhost-set-maintenance",
                    save  => 1,
                    vhost => $vhost,
                    off   => $off
               };
          }

          when ("vhost-list")
          {
               # vhost-list doesn't take any parameter

               # define action
               $self->{action} =
               {
                    type => "vhost-list",
                    save => 0
               };
          }

          ## global storage

          when ("global-storage")
          {
               # global-storage doesn't take any parameter

               # define action
               $self->{action} =
               {
                    type => "global-storage",
                    save => 0
               };
          }

          when ("global-storage-set-dir")
          {
               # global-storage takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $path = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "global-storage-set-dir",
                    save => 1,
                    path => $path
               };
          }

          when ("global-storage-set-lockdir")
          {
               # global-storage takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $path = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type => "global-storage-set-lockdir",
                    save => 1,
                    path => $path
               };
          }

          ## reload URLs

          when ("reload-urls")
          {
               # reload-urls doesn't take any parameter

               # define action
               $self->{action} =
               {
                    type => "reload-urls",
                    save => 0
               };
          }

          when ("reload-url-add")
          {
               # reload-url-add takes two parameters
               if ($self->{argc} < 3)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];
               my $url   = $self->{argv}[2];

               # define action
               $self->{action} =
               {
                    type  => "reload-url-add",
                    save  => 0,
                    vhost => $vhost,
                    url   => $url
               };
          }

          when ("reload-url-del")
          {
               # reload-url-del takes one parameter
               if ($self->{argc} < 2)
               {
                    $self->setError ("$_: ".$ERRORS->{TOO_FEW_ARGUMENTS});
                    return 0;
               }

               my $vhost = $self->{argv}[1];

               # define action
               $self->{action} =
               {
                    type  => "reload-url-del",
                    save  => 0,
                    vhost => $vhost
               };
          }

          # no action found
          default
          {
               $self->setError ("$_: ".$ERRORS->{UNKNOWN_ACTION});
               return 0;
          }
     }

     return 1;
}

## @method bool action ()
# Execute action parsed by parseCmd() method
#
# @return true on success, false otherwise
sub action
{
     my ($self) = @_;

     given ($self->{action}->{type})
     {
          ## Variables

          when ("set")
          {
               my $var = $self->{action}->{var};
               my $val = $self->{action}->{val};

               $self->{conf}->{$var} = $val;
          }

          when ("unset")
          {
               my $var = $self->{action}->{var};

               if (not defined ($self->{conf}->{$var}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no variables named '$var'");
                    return 0;
               }

               delete $self->{conf}->{$var};
          }

          when ("get")
          {
               my $var = $self->{action}->{var};

               if (not defined ($self->{conf}->{$var}))
               {
                    $self->setError ("$_: There is no variables named '$var'");
                    return 0;
               }

               print "$var = '", $self->{conf}->{$var}, "'\n";
          }

          ## Macros

          when ("set-macro")
          {
               my $m_name = $self->{action}->{name};
               my $m_expr = $self->{action}->{expr};

               $self->{conf}->{macros}->{$m_name} = $m_expr;
          }

          when ("unset-macro")
          {
               my $m_name = $self->{action}->{name};

               if (not defined ($self->{conf}->{macros}->{$m_name}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no macros named '$m_name'");
                    return 0;
               }

               delete $self->{conf}->{macros}->{$m_name};
          }

          when ("get-macro")
          {
               my $m_name = $self->{action}->{name};

               if (not defined ($self->{conf}->{macros}->{$m_name}))
               {
                    $self->setError ("$_: There is no macros named '$m_name'");
                    return 0;
               }

               print "$m_name = '", $self->{conf}->{macros}->{$m_name}, "'\n";
          }

          ## Applications

          when ("apps-set-cat")
          {
               my $catid   = $self->{action}->{id};
               my $catname = $self->{action}->{name};

               if (defined ($self->{conf}->{applicationList}->{$catid}))
               {
                    $self->{conf}->{applicationList}->{$catid}->{catname} = $catname;
               }
               else
               {
                    $self->{conf}->{applicationList}->{$catid} =
                    {
                         type    => "category",
                         catname => $catname
                    };
               }
          }

          when ("apps-get-cat")
          {
               my $catid = $self->{action}->{id};

               if (not defined ($self->{conf}->{applicationList}->{$catid}))
               {
                    $self->setError ("$_: There is no category '$catid'");
                    return 0;
               }

               print "$catid: ", $self->{conf}->{applicationList}->{$catid}->{catname}, "\n";
          }

          when ("apps-add")
          {
               my $appid = $self->{action}->{appid};
               my $catid = $self->{action}->{catid};

               if (not defined ($self->{conf}->{applicationList}->{$catid}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Category '$catid' doesn't exist");
                    return 0;
               }

               if (defined ($self->{conf}->{applicationList}->{$catid}->{$appid}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Application '$appid' exists");
                    return 0;
               }

               $self->{conf}->{applicationList}->{$catid}->{$appid} =
               {
                    type => "application",
                    options =>
                    {
                         logo        => "demo.png",
                         name        => $appid,
                         description => $appid,
                         display     => "auto",
                         uri         => "http://test1.example.com"
                    }
               };
          }

          when ("apps-set-uri")
          {
               my $appid  = $self->{action}->{id};
               my $appuri = $self->{action}->{uri};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              $app->{options}->{uri} = $appuri;
                              $found = 1;
                         }
                    }
               }

               if ($found == 0)
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Application '$appid' not found");
                    return 0;
               }
          }

          when ("apps-set-name")
          {
               my $appid   = $self->{action}->{id};
               my $appname = $self->{action}->{name};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              $app->{options}->{name} = $appname;
                              $found = 1;
                         }
                    }
               }

               if ($found == 0)
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Application '$appid' not found");
                    return 0;
               }
          }

          when ("apps-set-desc")
          {
               my $appid   = $self->{action}->{id};
               my $appdesc = $self->{action}->{desc};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              $app->{options}->{description} = $appdesc;
                              $found = 1;
                         }
                    }
               }

               if ($found == 0)
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Application '$appid' not found");
                    return 0;
               }
          }

          when ("apps-set-logo")
          {
               my $appid   = $self->{action}->{id};
               my $applogo = $self->{action}->{logo};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              $app->{options}->{logo} = $applogo;
                              $found = 1;
                         }
                    }
               }

               if ($found == 0)
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Application '$appid' not found");
                    return 0;
               }
          }

          when ("apps-set-display")
          {
               my $appid  = $self->{action}->{id};
               my $appdpy = $self->{action}->{dpy};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              $app->{options}->{display} = $appdpy;
                              $found = 1;
                         }
                    }
               }

               if ($found == 0)
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Application '$appid' not found");
                    return 0;
               }
          }

          when ("apps-get")
          {
               my $appid = $self->{action}->{id};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              print "Category '$catid': ".$self->{conf}->{applicationList}->{$catid}->{catname}."\n";
                              print "Application '$appid': ".$app->{options}->{name}."\n";
                              print "- Description: ".$app->{options}->{description}."\n";
                              print "- URI: ".$app->{options}->{uri}."\n";
                              print "- Logo: ".$app->{options}->{logo}."\n";
                              print "- Display: ".$app->{options}->{display}."\n";
                              $found = 1;
                         }
                    }
               }

               if ($found == 0)
               {
                    $self->setError ("$_: Application '$appid' not found");
                    return 0;
               }
          }

          when ("apps-rm")
          {
               my $appid = $self->{action}->{id};

               my $found = 0;
               while (my ($catid, $applist) = each %{$self->{conf}->{applicationList}} and $found != 1)
               {
                    while (my ($_appid, $app) = each %{$applist} and $found != 1)
                    {
                         if ($appid eq $_appid)
                         {
                              delete $applist->{$appid};
                              $found = 1;
                         }
                    }
               }
          }

          ## Rules

          when ("rules-set")
          {
               my $uri  = $self->{action}->{uri};
               my $expr = $self->{action}->{expr};
               my $rule = $self->{action}->{rule};

               if (not defined ($self->{conf}->{locationRules}->{$uri}))
               {
                    $self->{conf}->{locationRules}->{$uri} = {};
               }

               $self->{conf}->{locationRules}->{$uri}->{$expr} = $rule;
          }

          when ("rules-unset")
          {
               my $uri  = $self->{action}->{uri};
               my $expr = $self->{action}->{expr};

               if (not defined ($self->{conf}->{locationRules}->{$uri}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no virtual host '$uri'");
                    return 0;
               }

               if (not defined ($self->{conf}->{locationRules}->{$uri}->{$expr}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is rule '$expr' for virtual host '$uri'");
                    return 0;
               }

               delete $self->{conf}->{locationRules}->{$uri}->{$expr};
          }

          when ("rules-get")
          {
               my $uri = $self->{action}->{uri};

               if (not defined ($self->{conf}->{locationRules}->{$uri}))
               {
                    $self->setError ("$_: There is no virtual host '$uri'");
                    return 0;
               }

               print "Virtual Host : $uri\n";
               while (my ($expr, $rule) = each %{$self->{conf}->{locationRules}->{$uri}})
               {
                    print "- $expr => '$rule'\n";
               }
          }

          ## exported variables

          when ("export-var")
          {
               my $key = $self->{action}->{key};
               my $val = $self->{action}->{val};

               $self->{conf}->{exportedVars}->{$key} = $val;
          }

          when ("unexport-var")
          {
               my $key = $self->{action}->{key};

               if (not defined ($self->{conf}->{exportedVars}->{$key}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no exported variables named '$key'");
                    return 0;
               }

               delete $self->{conf}->{exportedVars}->{$key};
          }

          when ("get-exported-vars")
          {
               while (my ($key, $val) = each %{$self->{conf}->{exportedVars}})
               {
                    print "$key = $val\n";
               }
          }

          ## exported headers

          when ("export-header")
          {
               my $vhost  = $self->{action}->{vhost};
               my $header = $self->{action}->{header};
               my $expr   = $self->{action}->{expr};

               if (not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no virtual host '$vhost'\n");
                    return 0;
               }

               $self->{conf}->{exportedHeaders}->{$vhost}->{$header} = $expr;
          }

          when ("unexport-header")
          {
               my $vhost  = $self->{action}->{vhost};
               my $header = $self->{action}->{header};
               my $expr   = $self->{action}->{expr};

               if (not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no virtual host '$vhost'\n");
                    return 0;
               }

               if (not defined ($self->{conf}->{exportedHeaders}->{$vhost}->{$header}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no header named '$header' exported for virtual host '$vhost'\n");
                    return 0;
               }

               delete $self->{conf}->{exportedHeaders}->{$vhost}->{$header};
          }

          when ("get-exported-headers")
          {
               my $vhost = $self->{action}->{vhost};

               if (not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
               {
                    $self->setError ("$_: There is no virtual host '$vhost'\n");
                    return 0;
               }

               while (my ($header, $expr) = each %{$self->{conf}->{exportedHeaders}->{$vhost}})
               {
                    print "$header: '$expr'\n";
               }
          }

          ## virtual hosts

          when ("vhost-add")
          {
               my $vhost = $self->{action}->{vhost};

               if (defined ($self->{conf}->{vhostOptions}->{$vhost}) or defined ($self->{conf}->{locationRules}->{$vhost}) or defined ($self->{conf}->{exportedHeaders}->{$vhost}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": Virtual host '$vhost' already exist");
                    return 0;
               }

               $self->{conf}->{vhostOptions}->{$vhost} =
               {
                    vhostMaintenance => '0',
                    vhostPort => '-1',
                    vhostHttps => '-1'
               };
               $self->{conf}->{locationRules}->{$vhost} =
               {
                    default => "deny"
               };
               $self->{conf}->{exportedHeaders}->{$vhost} =
               {
                    "Auth-User" => "\$uid"
               };
          }

          when ("vhost-del")
          {
               my $vhost = $self->{action}->{vhost};
               my $error = "No virtual host in: ";
               my $nerror = 0;

               if (not defined ($self->{conf}->{vhostOptions}->{$vhost}))
               {
                    $nerror++;
                    $error .= "vhostOptions ";
               }
               else
               {
                    delete $self->{conf}->{vhostOptions}->{$vhost};
               }

               if (not defined ($self->{conf}->{locationRules}->{$vhost}))
               {
                    $nerror++;
                    $error .= "locationRules ";
               }
               else
               {
                    delete $self->{conf}->{locationRules}->{$vhost};
               }

               if (not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
               {
                    $nerror++;
                    $error .= "exportedHeaders";
               }
               else
               {
                    delete $self->{conf}->{exportedHeaders}->{$vhost};
               }

               if ($nerror == 3)
               {
                    $error .= ". abortting...";
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": $error");
                    return 0;
               }
               elsif ($nerror != 0)
               {
                    $error .= ". ignoring...";
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": $error");
               }
          }

          when ("vhost-set-port")
          {
               my $vhost = $self->{action}->{vhost};
               my $port  = $self->{action}->{port};

               if (not defined ($self->{conf}->{vhostOptions}->{$vhost}))
               {
                    if (not defined ($self->{conf}->{locationRules}->{$vhost}) and not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
                    {
                         $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no virtual host '$vhost'");
                         return 0;
                    }
                    else
                    {
                         $self->{conf}->{vhostOptions}->{$vhost} =
                         {
                              vhostPort => $port,
                              vhostHttps => '-1',
                              vhostMaintenance => '0'
                         };
                    }
               }
               else
               {
                    $self->{conf}->{vhostOptions}->{$vhost}->{vhostPort} = $port;
               }
          }

          when ("vhost-set-https")
          {
               my $vhost = $self->{action}->{vhost};
               my $https = $self->{action}->{https};

               if (not defined ($self->{conf}->{vhostOptions}->{$vhost}))
               {
                    if (not defined ($self->{conf}->{locationRules}->{$vhost}) and not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
                    {
                         $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no virtual host '$vhost'");
                         return 0;
                    }
                    else
                    {
                         $self->{conf}->{vhostOptions}->{$vhost} =
                         {
                              vhostPort => '-1',
                              vhostHttps => $https,
                              vhostMaintenance => '0'
                         };
                    }
               }
               else
               {
                    $self->{conf}->{vhostOptions}->{$vhost}->{vhostHttps} = $https;
               }
          }

          when ("vhost-set-maintenance")
          {
               my $vhost = $self->{action}->{vhost};
               my $off   = $self->{action}->{off};

               if (not defined ($self->{conf}->{vhostOptions}->{$vhost}))
               {
                    if (not defined ($self->{conf}->{locationRules}->{$vhost}) and not defined ($self->{conf}->{exportedHeaders}->{$vhost}))
                    {
                         $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no virtual host '$vhost'");
                         return 0;
                    }
                    else
                    {
                         $self->{conf}->{vhostOptions}->{$vhost} =
                         {
                              vhostPort => '-1',
                              vhostHttps => '-1',
                              vhostMaintenance => $off
                         };
                    }
               }
               else
               {
                    $self->{conf}->{vhostOptions}->{$vhost}->{vhostMaintenance} = $off;
               }
          }

          when ("vhost-list")
          {
               while (my ($vhost, $vhostoptions) = each %{$self->{conf}->{vhostOptions}})
               {
                    print "- $vhost => ";
                    print "Maintenance: $vhostoptions->{vhostMaintenance} | ";
                    print "Port: $vhostoptions->{vhostPort} | ";
                    print "HTTPS: $vhostoptions->{vhostHttps}\n";
               }
          }

          ## global storage

          when ("global-storage")
          {
               print "Global Storage options :\n";
               print "- Directory: $self->{conf}->{globalStorageOptions}->{Directory}\n";
               print "- Lock Directory: $self->{conf}->{globalStorageOptions}->{LockDirectory}\n";
          }

          when ("global-storage-set-dir")
          {
               my $path = $self->{action}->{path};

               $self->{conf}->{globalStorageOptions}->{Directory} = $path;
          }

          when ("global-storage-set-lockdir")
          {
               my $path = $self->{action}->{path};

               $self->{conf}->{globalStorageOptions}->{LockDirectory} = $path;
          }

          when ("reload-urls")
          {
               while (my ($vhost, $url) = each %{$self->{conf}->{reloadUrls}})
               {
                    print "- $vhost => $url\n";
               }
          }

          when ("reload-url-add")
          {
               my $vhost = $self->{action}->{vhost};
               my $url   = $self->{action}->{url};

               $self->{conf}->{reloadUrls}->{$vhost} = $url;
          }

          when ("reload-url-del")
          {
               my $vhost = $self->{action}->{vhost};

               if (not defined ($self->{conf}->{reloadUrls}->{$vhost}))
               {
                    $self->setError ("$_: ".$ERRORS->{CONFIG_WRITE_ERROR}.": There is no reload URLs setted for '$vhost'");
                    return 1;
               }

               delete $self->{conf}->{reloadUrls}->{$vhost};
          }

          # no implementation found
          default
          {
               $self->setError ("$_: ".$ERRORS->{NOT_IMPLEMENTED});
               return 0;
          }
     }

     return 1;
}

## @method void setError (string str)
# Set error message
#
# @param str Text of the error
sub setError
{
     my ($self, $msg) = @_;

     $self->{errormsg} = $msg;
}

## @method string getError ()
# Get error message
#
# @return Text of the error
sub getError
{
     my ($self) = @_;

     my $msg = $self->{errormsg};

     return $msg;
}

1;
__END__

=head1 NAME

=encoding utf8

Lemonldap::NG::Cli - Command Line Interface to edit LemonLDAP::NG configuration.

=head1 SYNOPSIS

  use Lemonldap::NG::Cli;
  
  my $app = Lemonldap::NG::Cli->new ();
  my $ret = $app->run (\@ARGV);
  exit ($ret);

=head1 DESCRIPTION

Lemonldap::NG::Cli allow user to edit the configuration of Lemonldap::NG via the
command line.

=head1 SEE ALSO

L<Lemonldap::NG>, L<Lemonldap::NG::Common::Conf>

=head1 AUTHOR

David Delassus E<lt>david.jose.delassus@gmail.comE<gt>

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2012, by David Delassus

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself, either Perl version 5.10.0 or,
at your option, any later version of Perl 5 you may have available.

=cut