<?php

class RegrasGrupos extends GxActiveRecord
{
    const TIPO_MOVIMENTACAO = 1;
    const TIPO_LISTAGEM = 2;
    const TIPO_FORMULARIO = 3;
    const TIPO_FILTRO = 4;
    public $tipos_regras = array(
        self::TIPO_MOVIMENTACAO => 'Tela de Movimentação',
        self::TIPO_LISTAGEM => 'Tela de Listagem',
        self::TIPO_FORMULARIO => 'Tela de Formulário',
        self::TIPO_FILTRO => 'Tela de Filtro',
    );

    const ORIGEM_LOCAL = 1;
    const ORIGEM_MOTIVO = 2;
    const ORIGEM_TELA = 3;

    public $tipos_origens = array(
        self::ORIGEM_LOCAL => 'Local',
        self::ORIGEM_MOTIVO => 'Motivo do tipo documentação',
        self::ORIGEM_TELA => 'Tela'
    );

    const RESTRICAO_PRIVILEGIO = 1;
    const RESTRICAO_PROJETO = 2;
    const RESTRICAO_USUARIO = 3;
    const RESTRICAO_MOTIVO = 4;
    const RESTRICAO_LOCAL_ATUAL = 11;
    const RESTRICAO_ORIGEM_ANTERIOR = 5;
    const RESTRICAO_SUPERVISOR = 12;
    const RESTRICAO_AUTOR = 6;
    const RESTRICAO_ANALISTA = 7;
    const RESTRICAO_DESENVOLVEDOR = 8;
    const RESTRICAO_TESTER = 9;
    const RESTRICAO_VENDEDOR = 10;
    const RESTRICAO_ACESSO_CLIENTE = 13;
    const RESTRICAO_RESPONSAVEL_VINCULADA = 14;
    public $lista_restricoes = array(
        self::RESTRICAO_PRIVILEGIO             => 'Privilégio',
        self::RESTRICAO_PROJETO                => 'Projeto',
        self::RESTRICAO_USUARIO                => 'Usuário',
        self::RESTRICAO_MOTIVO                 => 'Motivo',
        self::RESTRICAO_LOCAL_ATUAL            => 'Local atual',
        self::RESTRICAO_ORIGEM_ANTERIOR        => 'Local anterior',
        self::RESTRICAO_SUPERVISOR             => 'Usuário é o supervisor',
        self::RESTRICAO_AUTOR                  => 'Usuário é o autor',
        self::RESTRICAO_ANALISTA               => 'Usuário é o analista',
        self::RESTRICAO_DESENVOLVEDOR          => 'Usuário é o desenvolvedor',
        self::RESTRICAO_TESTER                 => 'Usuário é o tester',
        self::RESTRICAO_VENDEDOR               => 'Usuário é o vendedor',
        self::RESTRICAO_ACESSO_CLIENTE         => 'Usuário tem acesso ao cliente',
        self::RESTRICAO_RESPONSAVEL_VINCULADA  => 'Usuário é responsável por uma pendência vinculada',
    );

    public $RESTRICOES_DISPONIVEIS;
    public $RESTRICOES_SELECIONADAS;
    public $MOTIVOS_DISPONIVEIS;
    public $MOTIVOS_SELECIONADOS;

    public $LOCAL_ATUAL;

    /**
     * Returns the static model of the specified AR class.
     * @return CActiveRecord the static model class
     */
    public static function model($className=__CLASS__)
    {
        return parent::model($className);
    }

    /**
     * @return string the associated database table name
     */
    public function tableName()
    {
        return 'regras_grupos';
    }

    public static function label($n = 1)
    {
        return "Regras de Negócios";
    }

    public static function representingColumn()
    {
        return 'REG_NOME';
    }

    /**
     * @return array validation rules for model attributes.
     */
    public function rules()
    {
        return array(
            array('REG_NOME, REG_KEY, REG_TIPO, REG_TIPO_ORIGEM, REG_RESTRICOES', 'required'),
            array('RESTRICOES_DISPONIVEIS, RESTRICOES_SELECIONADAS, MOTIVOS_DISPONIVEIS, MOTIVOS_SELECIONADOS, LOCAL_ATUAL', 'safe'),
            array('RESTRICOES_SELECIONADAS', 'validaRestricoes'),
        );
    }

    /**
     * @return array relational rules.
     */
    public function relations()
    {
        return array(
        );
    }

    /**
     * @return array customized attribute labels (name=&gt;label)
     */
    public function attributeLabels()
    {
        return array(
            'REG_ID'          => 'Código',
            'REG_NOME'        => 'Nome',
            'REG_KEY'         => 'Chave',
            'REG_TIPO'        => 'Tipo',
            'REG_SITUACAO'    => 'Situação',
            'REG_TIPO_ORIGEM' => 'Tipo de Origem',
            'LOCAL_ATUAL'     => 'Tipo de local atual',
        );
    }

    public function validaRestricoes($attribute, $params)
    {
        if (empty($this->{$attribute})) {
            $this->addError($attribute, 'Selecione pelo menos uma restrição!');
            return false;
        } else {
            if (in_array(self::RESTRICAO_MOTIVO, $this->{$attribute})) {
                if (empty($this->MOTIVOS_SELECIONADOS)) {
                    $this->addError('MOTIVOS_SELECIONADOS', 'Selecione pelo menos um motivo!');
                    return false;
                }
            }
            if (in_array(self::RESTRICAO_LOCAL_ATUAL, $this->{$attribute})) {
                if (empty($this->LOCAL_ATUAL)) {
                    $this->addError('LOCAL_ATUAL', 'Selecione pelo menos um motivo!');
                    return false;
                }
            }
        }
        return true;
    }

    public function encodeJson()
    {
        if (!empty($this->RESTRICOES_SELECIONADAS)) {
            $restricoes = array();
            foreach ($this->RESTRICOES_SELECIONADAS as $restricao) {
                if ($restricao == self::RESTRICAO_MOTIVO) {
                    $restricoes[$restricao] = $this->MOTIVOS_SELECIONADOS;
                } elseif ($restricao == self::RESTRICAO_LOCAL_ATUAL) {
                    $restricoes[$restricao] = $this->LOCAL_ATUAL;
                } else {
                    $restricoes[$restricao] = $restricao;
                }
            }
            ksort($restricoes);
            $this->REG_RESTRICOES = CJSON::encode($restricoes);
        }

        return false;
    }

    public function decodeJson()
    {
        if (!$this->isNewRecord) {
            if (!empty($this->REG_RESTRICOES)) {
                $restricoesSelecionadas = CJSON::decode($this->REG_RESTRICOES);
                $this->RESTRICOES_SELECIONADAS = $restricoesSelecionadas;

                $restricoesDisponiveis = $this->lista_restricoes;
                foreach ($restricoesSelecionadas as $restricao => $valores) {
                    if ($restricao == self::RESTRICAO_LOCAL_ATUAL) {
                        $this->LOCAL_ATUAL = $valores;
                    }
                    unset($restricoesDisponiveis[$restricao]);
                }
                $this->RESTRICOES_DISPONIVEIS = $restricoesDisponiveis;
            }
        }
        return false;
    }

    public function search()
    {
        $criteria = new CDbCriteria;

        if (!empty($this->REG_ID)) {
            $criteria->compare('REG_ID', $this->REG_ID);
        }
        if (!empty($this->REG_NOME)) {
            $criteria->addCondition("REG_NOME LIKE '%{$this->REG_NOME}%'");
        }
        if (!empty($this->REG_TIPO)) {
            $criteria->compare('REG_TIPO', $this->REG_TIPO);
        }
        if (!empty($this->REG_SITUACAO)) {
            $criteria->compare('REG_SITUACAO', $this->REG_SITUACAO);
        }

        return new CActiveDataProvider($this, array(
            'criteria' => $criteria,
            'sort' => array(
                'defaultOrder' => 'REG_SITUACAO DESC',
            ),
            'pagination' => array(
                'pageSize'  => 20,
            )
        ));
    }

    public function getSingleRestricoes()
    {
        $keys = array(
            self::RESTRICAO_SUPERVISOR,
            self::RESTRICAO_AUTOR,
            self::RESTRICAO_ANALISTA,
            self::RESTRICAO_DESENVOLVEDOR,
            self::RESTRICAO_TESTER,
            self::RESTRICAO_VENDEDOR,
            self::RESTRICAO_ACESSO_CLIENTE,
            self::RESTRICAO_RESPONSAVEL_VINCULADA,
        );

        $retorno = array();
        foreach ($keys as $key) {
            $retorno[$key] = $this->lista_restricoes[$key];
        }

        return $retorno;
    }

    public function getTipo($tipo = false)
    {
        if (!$tipo) {
            $tipo = $this->REG_TIPO;
        }
        return $this->tipos_regras[$tipo];
    }

    public function getTipoOrigem($tipo = false, $model = false) {
        if (!$tipo) {
            $tipo = $this->REG_TIPO;
        }

        if (!$model) {
            return $this->tipos_origens[$tipo];
        } else {
            switch ($tipo) {
                case self::ORIGEM_LOCAL:
                    return 'Locais';
                    break;
                case self::ORIGEM_MOTIVO;
                    return 'Motivos';
                    break;
                default:
                    // return 'AclPermissoes';
                    break;
            }
        }
    }

    public function getTipoRestricao($tipo)
    {
        return $this->lista_restricoes[$tipo];
    }

    public function getTiposOrigem($tipo)
    {
        switch ($tipo) {
            case self::TIPO_MOVIMENTACAO:
                $tipos = $this->tipos_origens;
                unset($tipos[self::ORIGEM_TELA]);
                return $tipos;
                break;

            default:
                return array(
                    self::ORIGEM_TELA => $this->tipos_origens[self::ORIGEM_TELA],
                );
                break;
        }
    }

    public function getTiposAcoes()
    {
        $acoes = array();
        if (!empty($this->REG_TIPO)) {
            if ($this->REG_TIPO == RegrasGrupos::TIPO_MOVIMENTACAO) {
                $acoes = array(
                    RegrasNegocio::ACAO_MOVIMENTAR => RegrasNegocio::model()->getTipoAcao(RegrasNegocio::ACAO_MOVIMENTAR)
                );
            } else {
                $acoes = RegrasNegocio::model()->TIPOS_ACOES;
                unset($acoes[RegrasNegocio::ACAO_MOVIMENTAR]);
            }
        }
        return $acoes;
    }
    ///
    public function getOrigem($tipo = false, $agrupar = true)
    {
        $tipo = (!$tipo) ? $this->REG_TIPO_ORIGEM : $tipo;
        $origem = array();
        switch ($tipo) {
            case RegrasGrupos::ORIGEM_LOCAL:
                $locais = Locais::model()->findAll('LOC_SITUACAO = 1 ORDER BY LOC_DESCRICAO ASC');
                $origem = CHtml::listData($locais, 'LOC_IDLOCAL', 'LOC_DESCRICAO');
                break;
            case RegrasGrupos::ORIGEM_MOTIVO:
                $motivos = Motivos::model()->findAll('MOT_TIPO = 6 AND MOT_SITUACAO = "A"');
                $origem = CHtml::listData($motivos, 'MOT_IDMOTIVO', 'MOT_DESCRICAO');
                break;
            default:
                // $origem = AclPermissoes::model()->getTelas($this->REG_TIPO, false, $agrupar);
                break;
        }
        return $origem;
    }

    function getCondicoes()
    {
        $restricoes = array();

        $restricoesGrupo = CJSON::decode($this->REG_RESTRICOES);
        if (!empty($restricoesGrupo)) {
            foreach ($restricoesGrupo as $restricao => $valores) {
                switch ($restricao) {
                    case RegrasGrupos::RESTRICAO_PRIVILEGIO:
                        $privilegios = Privilegios::model()->findAll('PRI_SITUACAO = "A" ORDER BY PRI_DESCRICAO ASC');
                        $privilegiosToJson = array();
                        foreach ($privilegios as $key => $privilegio) {
                            $privilegiosToJson[$key]['codigo'] = $privilegio->PRI_ID;
                            $privilegiosToJson[$key]['valor'] = $privilegio->PRI_DESCRICAO;
                        }
                        $privilegios = CHtml::listData($privilegios, 'PRI_ID', 'PRI_DESCRICAO');

                        $restricoes[RegrasGrupos::RESTRICAO_PRIVILEGIO]['options'] = $privilegios;
                        $restricoes[RegrasGrupos::RESTRICAO_PRIVILEGIO]['json'] = CJSON::encode($privilegiosToJson);

                        break;
                    case RegrasGrupos::RESTRICAO_PROJETO:
                        $projetos = Projetos::model()->findAll('PRO_STATUS = 1');
                        $projetosToJson = array();
                        foreach ($projetos as $key => $projeto) {
                            $projetosToJson[$key]['codigo'] = $projeto->PRO_IDPROJETO;
                            $projetosToJson[$key]['valor'] = $projeto->PRO_PROJETO;
                        }
                        $projetos = CHtml::listData($projetos, 'PRO_IDPROJETO', 'PRO_PROJETO');

                        $restricoes[RegrasGrupos::RESTRICAO_PROJETO]['options'] = $projetos;
                        $restricoes[RegrasGrupos::RESTRICAO_PROJETO]['json'] = CJSON::encode($projetosToJson);

                        break;
                    case RegrasGrupos::RESTRICAO_USUARIO:
                        $funcionarios = Funcionarios::model()->findAll('FUN_SITUACAO = "A" ORDER BY FUN_NOME ASC');
                        $funcionariosToJson = array();
                        foreach ($funcionarios as $key => $funcionario) {
                            $funcionariosToJson[$key]['codigo'] = $funcionario->FUN_IDFUNCIONARIO;
                            $funcionariosToJson[$key]['valor'] = $funcionario->FUN_NOME;
                        }
                        $funcionarios = CHtml::listData($funcionarios, 'FUN_IDFUNCIONARIO', 'FUN_NOME');

                        $restricoes[RegrasGrupos::RESTRICAO_USUARIO]['options'] = $funcionarios;
                        $restricoes[RegrasGrupos::RESTRICAO_USUARIO]['json'] = CJSON::encode($funcionariosToJson);

                        break;
                    case RegrasGrupos::RESTRICAO_MOTIVO:
                        $motivos = Motivos::model()->findAll("MOT_IDMOTIVO IN (" . implode(", ", $valores) . ") ORDER BY MOT_DESCRICAO");
                        $motivosToJson = array();
                        foreach ($motivos as $key => $motivo) {
                            $motivosToJson[$key]['codigo'] = $motivo->MOT_IDMOTIVO;
                            $motivosToJson[$key]['valor'] = $motivo->MOT_DESCRICAO;
                        }

                        $motivos = CHtml::listData($motivos, 'MOT_IDMOTIVO', 'MOT_DESCRICAO');
                        $restricoes[RegrasGrupos::RESTRICAO_MOTIVO]['options'] = $motivos;
                        $restricoes[RegrasGrupos::RESTRICAO_MOTIVO]['json'] = CJSON::encode($motivosToJson);

                        break;
                    case RegrasGrupos::RESTRICAO_LOCAL_ATUAL:
                        $locais = $this->getOrigem($valores);
                        $locaisToJson = array();

                        $key = 0;
                        foreach ($locais as $codigo => $valor) {
                            $locaisToJson[$key]['codigo'] = $codigo;
                            $locaisToJson[$key]['valor'] = $valor;
                            $key++;
                        }
                        $restricoes[RegrasGrupos::RESTRICAO_LOCAL_ATUAL]['options'] = $locais;
                        $restricoes[RegrasGrupos::RESTRICAO_LOCAL_ATUAL]['json'] = CJSON::encode($locaisToJson);
                        break;
                    case RegrasGrupos::RESTRICAO_ORIGEM_ANTERIOR:
                        if ($this->REG_TIPO_ORIGEM == RegrasGrupos::TIPO_MOVIMENTACAO) {
                            $origem = $this->getOrigem();
                            $origemToJson = array();

                            $key = 0;
                            foreach ($origem as $codigo => $valor) {
                                $origemToJson[$key]['codigo'] = $codigo;
                                $origemToJson[$key]['valor'] = $valor;
                                $key++;
                            }
                            $restricoes[RegrasGrupos::RESTRICAO_ORIGEM_ANTERIOR]['options'] = $origem;
                            $restricoes[RegrasGrupos::RESTRICAO_ORIGEM_ANTERIOR]['json'] = CJSON::encode($origemToJson);
                        }
                        break;
                    default:
                        $opcoes = array(1 => 'Sim', 0 => 'Não');
                        $opcoesToJson = array(
                            0 => array('codigo' => 1, 'valor' => 'Sim'),
                            1 => array('codigo' => 0, 'valor' => 'Não'),
                        );
                        $restricoes[$restricao]['options'] = $opcoes;
                        $restricoes[$restricao]['json'] = CJSON::encode($opcoesToJson);

                        break;
                }
            }
        }

        return $restricoes;
    }
}
