package Lemonldap::NG::Manager::Cli;

# Required packages

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

use feature qw (switch);

# Constants

our $VERSION = "1.3.0";

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::Manager::Cli new ()
# Create a new Lemonldap::NG::Manager::Cli object
#
# @return New Lemonldap::NG::Manager::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] ) {

        ## Help

        when ("help") {

            # define action
            $self->{action} = {
                type => "help",
                save => 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 ("help") {
            $self->displayHelp();
        }

        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;
}

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

    print STDERR "
Set/get variables in the configuration:

  lemonldap-ng-cli set <variable> <value>
  lemonldap-ng-cli unset <variable>
  lemonldap-ng-cli get <variable>

Define macros:

  lemonldap-ng-cli set-macro <macro name> <perl expression>
  lemonldap-ng-cli unset-macro <macro name>
  lemonldap-ng-cli get-macro <macro name>

Modify application list:

  lemonldap-ng-cli apps-set-cat <cat id> <cat name>
  lemonldap-ng-cli apps-get-cat <cat id>
  
  lemonldap-ng-cli apps-add <app id> <cat id>
  lemonldap-ng-cli apps-set-uri <app id> <app uri>
  lemonldap-ng-cli apps-set-name <app id> <app name>
  lemonldap-ng-cli apps-set-desc <app id> <app description>
  lemonldap-ng-cli apps-set-logo <app id> <logo>
  lemonldap-ng-cli apps-set-display <app id> <app display>
  
  lemonldap-ng-cli apps-get <app id>
  lemonldap-ng-cli apps-rm <app id>

Manage rules:

  lemonldap-ng-cli rules-set <virtual host> <expr> <rule>
  lemonldap-ng-cli rules-unset <virtual host> <expr>
  lemonldap-ng-cli rules-get <virtual host>

Manage exported variables:

  lemonldap-ng-cli export-var <key> <value>
  lemonldap-ng-cli unexport-var <key>
  lemonldap-ng-cli get-exported-vars

Manage exported headers:

  lemonldap-ng-cli export-header <virtual host> <HTTP header> <perl expression>
  lemonldap-ng-cli unexport-header <virtual host> <HTTP header>
  lemonldap-ng-cli get-exported-headers <virtual host>

Manage virtual hosts:

  lemonldap-ng-cli vhost-add <virtual host uri>
  lemonldap-ng-cli vhost-del <virtual host>
  lemonldap-ng-cli vhost-set-port <virtual host> <port>
  lemonldap-ng-cli vhost-set-https <virtual host> <value>
  lemonldap-ng-cli vhost-set-maintenance  <virtual host> <value>
  lemonldap-ng-cli vhost-list

Global Storage:

  lemonldap-ng-cli global-storage
  lemonldap-ng-cli global-storage-set-dir <path>
  lemonldap-ng-cli global-storage-set-lockdir <path>

Reload URLs:

  lemonldap-ng-cli reload-urls
  lemonldap-ng-cli reload-url-add <vhost> <url>
  lemonldap-ng-cli reload-url-del <vhost>

";

}

1;
__END__

=head1 NAME

=encoding utf8

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

=head1 SYNOPSIS

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

=head1 DESCRIPTION

Lemonldap::NG::Manager::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>
Clement Oudot E<lt>clem.oudot@gmail.comE<gt>

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2012, by David Delassus
Copyright (C) 2013, by Clement Oudot

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