";print_r($this->id);exit;
            }*/

            return parent::afterFind();
        }

	public function getRifEmpresa(){
		return str_replace( ['-','.'],'',Empresa::model()->find()->rif_emp);
	}
	public function getNumeroCuentaDebitar(){
		return $this->idParamBanco->num_cuenta;
	}
	public function getCodigoServicio(){

		return $this->idBancoTipoServicio->codigo_servicio;
	}

	/**
	 * Returns the static model of the specified AR class.
	 * Please note that you should have this exact method in all your CActiveRecord descendants!
	 * @param string $className active record class name.
	 * @return PagosMasivos the static model class
	 */
	public static function model($className=__CLASS__)
	{
		return parent::model($className);
	}

    public function getIdComprobantePago()
    {
        return $this->idComprobantePago;
    }

    public function setIdComprobantePago($idComprobantePago)
    {
        $this->idComprobantePago = $idComprobantePago;
	}

	public function getTituloProceso()
    {
        return $this->tituloProceso;
    }

    public function setTituloProceso($tituloProceso)
    {
        $this->tituloProceso = $tituloProceso;
    }

    public function getConfIntegrado()
    {
        $conf = Yii::app()->getDb()->createCommand('
            SELECT bta.*,
                   bts.tipo_descarga
            FROM configuracion.banco_tipo_archivo bta
            INNER JOIN configuracion.banco_tipo_servicio bts ON bta.id_banco_tipo_servicio=bts.id
            WHERE bta.id_banco=:id_banco
              AND bta.id_tipo_archivo=1
        ')->bindValue('id_banco', $this->idParamBanco->id_banco)->queryRow();

        if (empty($conf)) {
            return false;
        }

        return $conf;
    }

    public function getConfSeparados()
    {
        $conf = BancoTipoArchivo::model()->findAll([
            'alias' => 'bta',
            'join' => 'inner join configuracion.banco_tipo_servicio bts on bts.id=bta.id_banco_tipo_servicio',
            'condition' => 'id_banco=:id_banco and borrado is false',
            'order' => 'bts.tipo_descarga',
            'params' => [
                'id_banco' => $this->idParamBanco->id_banco
            ]
        ]);

        if (is_null($conf)) {
            return false;
        }

        if (count($conf) == 1) {
            return false;
        }

        return $conf;
    }

    public function cargarPagos($nomina)
    {
        if ($this->id_tipo_archivo == 2) {
            return $this->separados($nomina);
        }

        return $this->integrado($nomina);
    }

    public function integrado($nomina)
    {
        $confIntegrado = $this->getConfIntegrado();

        if (! $confIntegrado) {
            return array(
                'error' => true,
                'mensaje' => 'Es necesario definir una configuración para tipos de archivos integrado',
            );
        }
        $this->total_pago = $nomina->totalRetiros();
        $this->cant_pago = $nomina->cantidadRetiros();
        $this->id_banco_tipo_servicio = $confIntegrado['id_banco_tipo_servicio'];
        $this->id_banco_tipo_archivo = $confIntegrado['id'];
        $this->tipo_descarga = $confIntegrado['tipo_descarga'];
        if (! $this->validate()) {
            return array(
                'error' => true,
                'mensaje' => 'Datos del encabezado invalidos',
            );
        }

        $transaction = Yii::app()->db->beginTransaction();
        try {
            if(! $this->save()) {
                $transaction->rollBack();
                return array(
                    'error' => true,
                    'mensaje' => 'No se pudo guardar el encabezado.',
                );
            }

            $modelSeguimiento = new PagosMasivosSeguimiento();
            $modelSeguimiento->id_pagos_masivos = $this->id;
            $modelSeguimiento->id_estatus_pagos = 1;
            if(! $modelSeguimiento->save()){
                $transaction->rollBack();
                return array(
                    'error' => true,
                    'mensaje' => 'No se pudo guardar el seguimiento del pago.',
                );
            }

            foreach ($nomina->retiros as $retiro) {
                $modelDetalle = new PagosMasivosDetalle();
                $modelDetalle->id_proceso = $retiro->id;
                $modelDetalle->id_nombre_proceso = $this->id_tipo_pagos_masivos;
                $modelDetalle->id_pagos_masivos = $this->id;
                $modelDetalle->id_estatus_detalle = 1;
                if(! $modelDetalle->save()) {
                    $transaction->commit();
                    return array(
                        'error' => true,
                        'mensaje' => 'No se pudo guardar el detalle del archivo.',
                    );
                }
            }

            SeguimientoTxtIntegradoPagosMasivos::model()->updateAll(array('actual' => false), 'id_datos_txt_integrado=:nomina', array(':nomina' => $nomina->id));
            $seguimientoTxtPagos = new SeguimientoTxtIntegradoPagosMasivos;
            $seguimientoTxtPagos->id_datos_txt_integrado = $nomina->id;
            $seguimientoTxtPagos->id_pagos_masivos = $this->id;
            $seguimientoTxtPagos->id_usuario = Yii::app()->user->id;
            if (! $seguimientoTxtPagos->save()) {
                $transaction->commit();
                return array(
                    'error' => true,
                    'mensaje' => 'No se pudo guardar el seguimiento de la nomina con el pago masivo.',
                );
            }

            $transaction->commit();
            return array(
                'error' => false,
                'mensaje' => 'Los datos han sido registrado exitosamente',
            );
        } catch (Exception $e) {
            $transaction->rollBack();
            throw new CHttpException(400, $e->getMessage());
        }
    }

    public function separados($nomina)
    {
        $confSeparados = $this->getConfSeparados();

        if (! $confSeparados) {
            return array(
                'error' => true,
                'mensaje' => 'Es necesario definir una configuración para tipos de archivos separados',
            );
        }

        $nominas = array_filter([
            $nomina->mismoBanco($this->id_param_banco),
            $nomina->otrosBancos($this->id_param_banco)
        ]);
        $tiposDescargas = [1, 2];

        $transaction = Yii::app()->db->beginTransaction();
        try {
            foreach ($nominas as $key => $asociados) {
                $pagoMasivo = new PagosMasivos('registro_ae');
                $pagoMasivo->attributes = $this->attributes;
                $pagoMasivo->total_pago = $nomina->total($asociados);
                $pagoMasivo->cant_pago = $nomina->cantidad($asociados);
                $pagoMasivo->id_banco_tipo_servicio = $confSeparados[$key]->id_banco_tipo_servicio;
                $pagoMasivo->id_banco_tipo_archivo = $confSeparados[$key]->id;
                $pagoMasivo->tipo_descarga = $tiposDescargas[$key];
                if (! $pagoMasivo->validate()) {
                    $transaction->rollBack();
                    return array(
                        'error' => true,
                        'mensaje' => 'Datos del encabezado invalidos',
                    );
                }
                $pagoMasivo->save();

                $modelSeguimiento = new PagosMasivosSeguimiento();
                $modelSeguimiento->id_pagos_masivos = $pagoMasivo->id;
                $modelSeguimiento->id_estatus_pagos = 1;
                if(! $modelSeguimiento->validate()) {
                    $transaction->rollBack();
                    return array(
                        'error' => true,
                        'mensaje' => 'No se pudo guardar el seguimiento del pago.',
                    );
                }
                $modelSeguimiento->save();

                foreach ($asociados as $asociado) {
                    $modelDetalle = new PagosMasivosDetalle();
                    $modelDetalle->id_proceso = $asociado->id;
                    $modelDetalle->id_nombre_proceso = $pagoMasivo->id_tipo_pagos_masivos;
                    $modelDetalle->id_pagos_masivos = $pagoMasivo->id;
                    $modelDetalle->id_estatus_detalle = 1;
                    if(! $modelDetalle->validate()) {
                        $transaction->rollBack();
                        return array(
                            'error' => true,
                            'mensaje' => 'No se pudo guardar el detalle del archivo.',
                        );
                    }
                    $modelDetalle->save();
                }

                SeguimientoTxtIntegradoPagosMasivos::model()->updateAll(array('actual' => false), 'id_datos_txt_integrado=:nomina', array(':nomina' => $nomina->id));
                $seguimientoTxtPagos = new SeguimientoTxtIntegradoPagosMasivos;
                $seguimientoTxtPagos->id_datos_txt_integrado = $nomina->id;
                $seguimientoTxtPagos->id_pagos_masivos = $pagoMasivo->id;
                $seguimientoTxtPagos->id_usuario = Yii::app()->user->id;
                if (! $seguimientoTxtPagos->validate()) {
                    $transaction->rollBack();
                    return array(
                        'error' => true,
                        'mensaje' => 'No se pudo guardar el seguimiento de la nomina con el pago masivo.',
                    );
                }
                $seguimientoTxtPagos->save();
            }
            $transaction->commit();

            return array(
                'error' => false,
                'mensaje' => 'Los datos han sido registrado exitosamente',
            );
        } catch (Exception $e) {
            $transaction->rollBack();
            throw new CHttpException(400, $e->getMessage());
        }
    }

    public function pagarArchivoAportesEspeciales($idProceso)
    {
        $aporte = AporteVoluntario::model()->findByPk($idProceso);
        $pmDetalle = PagosMasivosDetalle::model()->find([
            'condition' => 'id_proceso=:id and blnborrado IS FALSE',
            'params' => ['id' => $idProceso]
        ]);

        if ($pmDetalle->id_estatus_detalle == 3) {
            EstatusAporteVoluntario::seguimiento($aporte->id, 6);
        } elseif ($aporte->opcion_retiro == 2) {
            EstatusAporteVoluntario::seguimiento($aporte->id, 3);
        } elseif ($aporte->opcion_retiro == 3) {
            EstatusAporteVoluntario::seguimiento($aporte->id, 5);
        }
    }

    public function pagarNominaAporte()
    {
        foreach ($this->nominasDetallePagoMasivo() as $nomina) {
            if ($this->aportesPorPagar($nomina['id']) == 0) {
                EstatusTxtIntegrado::seguimiento($nomina['id'], 5);
            }
        }
    }

    public function unidadesDesdeDetallePagoMasivo()
    {
        return Yii::app()->getDb()->createCommand('
            SELECT a.idunidad AS id_unidad
            FROM pagos.pagos_masivos_detalle pmd
            INNER JOIN retiro.retiro_parcial rp ON pmd.id_proceso=rp.id
            INNER JOIN asociado a ON rp.idasociado=a.idasociado
            WHERE id_pagos_masivos=:id
            GROUP BY id_unidad
        ')->bindValue('id', $this->id)->queryAll();
    }

    public function fechaComprobanteEscenariosContables()
    {
        Yii::import('application.modules.contable.models.*', true);
        switch ($this->id_tipo_pagos_masivos) {
            case 1: // prestamo
                return ParamEscenarios::fechaComprobante(['prestamos' => 4]);
            case 2: // retiros
                return ParamEscenarios::fechaComprobante(['retiros' => 1]);
            case 10: // orden de pago
                return ParamEscenarios::fechaComprobante(['pagar_orden_pago' => 8]);
        }
    }

    private function nominasDetallePagoMasivo()
    {
        return Yii::app()->getDb()->createCommand('
            SELECT DISTINCT id_txt_integrado as id
            FROM retenciones.aporte_voluntario
            WHERE id IN
                (SELECT id_proceso
                 FROM pagos.pagos_masivos_detalle
                 WHERE id_pagos_masivos=:id)
        ')->bindValue('id', $this->id)->queryAll();
    }

    private function aportesPorPagar($idNomina)
    {
        return Yii::app()->getDb()->createCommand('
            SELECT cant_aportantes -
              (SELECT count(*)
               FROM retenciones.aporte_voluntario av
               INNER JOIN retenciones.estatus_aporte_voluntario eav ON av.id=eav.id_aporte_voluntario
               AND eav.actual IS TRUE
               AND eav.id_status_av=3
               WHERE av.id_txt_integrado=dti.id) res
            FROM retenciones.datos_txt_integrado dti
            WHERE dti.id=:id
        ')->bindValue('id', $idNomina)->queryRow()['res'];
	}

	public static function bancoCuentaContable($idParamBanco)
    {
        return Yii::app()->getDb()->createCommand('
            SELECT clvcuenta
            FROM configuracion.param_bancos
            WHERE id=:id AND estatus IS TRUE;
        ')->bindValue('id', $idParamBanco)->queryRow()['clvcuenta'];
    }

    public function afianzadoras()
    {
        return Yii::app()->getDb()->createCommand('
            SELECT c.id_afianzadora as id,
                    pmd.id_proceso,
                    a.descripcion,
                    a.id_proveedor,
                    case when (select conf_unidad from contable.param_contables where clave=\'cta_fianza_prestamo\') IS FALSE
                            then (select valor::integer from contable.param_contables where clave=\'cta_fianza_prestamo\')
                            else p.id_cuenta
                    end as id_cuenta,
                    p.id_tipo_persona,
                    p.rif,
                    pcb.id as id_proveedor_cuenta_banco,
                    case when count(pp.id) > 0 then concat(
                            \'Fecha de pago: \', to_char(pp.fecha_pago, \'DD-MM-YYYY\'),
                            \'Referencia: \', pp.referencia,
                            \'Banco: \', pb.banco,
                            \'Número cuenta: \', pb.num_cuenta,
                            \'Tipo de crédito: \', tc.descripcion
                        ) 
                    end as descripcion,
                    coalesce(sum(c.gastos_administrativos_afianzadora),0) + coalesce(sum(c.gastos_administrativos_afianzadora_caja),0) as gastos_administrativos_afianzadora
            FROM pagos.pagos_masivos_detalle pmd
            INNER JOIN prestamos.credito c ON pmd.id_proceso=c.id
            INNER JOIN prestamos.afianzadora a ON a.id=c.id_afianzadora AND a.blnborrado is false
            inner join prestamos.tipo_credito tc on tc.id=c.id_tipo_credito
            LEFT JOIN proveedor p ON p.id=a.id_proveedor AND p.blnborrado is false
            LEFT JOIN proveedor_cuenta_banco pcb ON pcb.idproveedor=a.id_proveedor AND pcb.cuenta_principal is true
            left join contable.proceso_pago pp on pp.id_proceso=pmd.id_proceso
                and pp.id_nombre_proceso=pmd.id_nombre_proceso
                and pp.actual is true
            left join configuracion.param_bancos pb on pb.id=pp.id_banco
            WHERE pmd.id_pagos_masivos=:id
                AND pmd.id_estatus_detalle=2
                AND pmd.blnborrado is false
                AND c.id_afianzadora IS NOT NULL
            GROUP BY c.id_afianzadora, pmd.id_proceso, a.id_proveedor, id_cuenta, p.id_tipo_persona, p.rif, pcb.id,
                a.descripcion, pp.fecha_pago,pp.referencia, pb.banco, pb.num_cuenta, tc.descripcion
            HAVING coalesce(sum(c.gastos_administrativos_afianzadora),0) + coalesce(sum(c.gastos_administrativos_afianzadora_caja),0) > 0
        ')->bindValues(['id' => $this->id])->queryAll();
    }

    public function generarOrdenPagoAfianzadoras()
    {
        Yii::import('application.modules.configuracion.models.*');

        foreach ($this->afianzadoras() as $afianzadora) {
            if (is_null($afianzadora['id_proveedor'])) {
                throw new Exception("La afianzadora {$afianzadora['descripcion']}, no tiene un proveedor asociado.");
            }

            OrdenPago::generar([
                'id_tipo_orden' => 1,
                'id_tipo_carga' => 3,
                'id_concepto' => ConceptosOrdenPago::proceso(8),
                'id_tipo_persona' => $afianzadora['id_tipo_persona'],
                'rif' => $afianzadora['rif'],
                'idbanco' => $afianzadora['id_proveedor_cuenta_banco'],
                'monto_pago' => Yii::app()->format->number($afianzadora['gastos_administrativos_afianzadora']),
                'idproveedor' => $afianzadora['id_proveedor'],
                'descripcion' => vsprintf("%s Monto: %s", [
                    $afianzadora['descripcion'],
                    Yii::app()->format->number($afianzadora['gastos_administrativos_afianzadora'])
                ]),
            ], 2);
        }
    }

    public function getUltimoComprobante()
    {
        return $this->ultimoComprobante;
    }

    public function getFechaComprobante()
    {
        if ($this->hasComprobante()) {
            return $this->getUltimoComprobante()->fecha_comprobante;
        }

        return;
    }

    public function countPagos()
    {
        return Yii::app()->getDb()->createCommand('
            select count(id_proceso) as procesos
            from pagos.pagos_masivos_detalle pmd
            where pmd.id_pagos_masivos=:pago_masivo and blnborrado is false
        ')->bindValues(['pago_masivo' => $this->id])->queryRow()['procesos'];
    }

    public function validacionFechaComprobante()
    {
        Yii::import('application.modules.contable.models.*', true);
        return (ParamEscenarios::fechaComprobante(['pago_prestaos' => 4])
            || ParamEscenarios::fechaComprobante(['pagar_retiro_parcial' => 1]))
            && $this->hasComprobante();
    }

    public function hasComprobante()
    {
        return $this->id_comprobante !== null;
    }

    public function reversarPago()
    {
        $transaction = Yii::app()->getDb()->beginTransaction();
        try {
            switch ($this->id_tipo_pagos_masivos) {
                case 1: // Préstamos
                    $this->reversarNominaPrestamos();
                    break;
                case 2: // Retiros
                    $this->reversarNominaRetiroParciales();
                    break;
                // case 3: // Liquidaciones
                //     $this->reversarNominaRetiroParciales();
                //     break;
            }

            $this->reversarNominaPagoMasivo();

            // Reversa detalle de la nomina masiva a reservada
            PagosMasivosDetalle::model()->updateAll(['id_estatus_detalle' => 1], 'id_pagos_masivos=:pago_masivo and blnborrado is false', ['pago_masivo' => $this->id]);

            $this->reversarComprobantesDePago();
            
            $transaction->commit();
            Yii::app()->user->setFlash('success', 'Nómina de pago masivo reversada correctamente.');

            return true;
        } catch(Exception $e) {
            $transaction->rollback();

            if ($e->getCode() == 10) {
                return false;
            }

            Yii::app()->user->setFlash('error', $e->getMessage());

            return false;
        }
    }

    protected function reversarNominaPrestamos()
    {
        if ($this->hasComprobante()) {
            Yii::import('application.modules.contable.models.*', true);
            Yii::import('application.modules.contable.models.comprobantes.*', true);
            Yii::import('application.modules.contable.models.comprobantes.retiro.*', true);
            $comprobante = $this->ultimoComprobante;

            if (strtotime($this->fecha_comprobante) < strtotime($comprobante->fecha_comprobante)) {
                $this->addError('fecha_comprobante', 'La fecha de comprobante no puede ser menor la fecha de contabilización.');
                throw new Exception('La fecha de comprobante es invalida.', 10);
            }

            $this->setIdComprobantePago($comprobante->id);
            $this->num_comprobante = $comprobante->nro_documento;
            $this->fecha_referencia = $this->fecha_comprobante;
            $this->setTituloProceso($this->id_tipo_pagos_masivos);
            (new ReversoMasivo($this))->contabilizar();
        }

        foreach ($this->pagosMasivosDetalles as $pagoMasivoDetalle) {
            $prestamo = Credito::model()->findByPk($pagoMasivoDetalle->id_proceso);

            if ($prestamo->hasLiquidacion()) {
                throw new Exception("No se puede reversar pago masivo de préstamos, hay asociados con liquidaciones.");
            }
            
            if ($prestamo->cuotasModificadas()) {
                throw new Exception('Hay créditos con cuotas modificadas no se puede reversar la nómina.');
            }
            
            // Reversa prestamo a aprobado
            $prestamo->reversarCredito();

            // Reversa prestamos anteriores junto con las cuotas de la tabla de amortizacion
            $prestamo->reversarCreditosAnteriores();

            $prestamo->reversarComprobantePago();
        }
    }

    protected function reversarNominaRetiroParciales()
    {
        if ($this->hasComprobante()) {
            Yii::import('application.modules.contable.models.*', true);
            Yii::import('application.modules.contable.models.comprobantes.*', true);
            Yii::import('application.modules.contable.models.comprobantes.retiro.*', true);
            $comprobante = $this->ultimoComprobante;

            if (strtotime($this->fecha_comprobante) < strtotime($comprobante->fecha_comprobante)) {
                $this->addError('fecha_comprobante', 'La fecha de comprobante no puede ser menor la fecha de contabilización.');
                throw new Exception('La fecha de comprobante es invalida.', 10);
            }

            $this->setIdComprobantePago($comprobante->id);
            $this->num_comprobante = $comprobante->nro_documento;
            $this->fecha_referencia = $this->fecha_comprobante;
            $this->setTituloProceso($this->id_tipo_pagos_masivos);
            (new ReversoMasivo($this))->contabilizar();
        }

        // reversa los prestamos pagados por el retiro parcial
        foreach ($this->pagosMasivosDetalles as $pagoMasivoDetalle) {
            $model = RetiroParcial::model()->findByPk($pagoMasivoDetalle->id_proceso);

            if ($model->liquidacion()) {
                throw new Exception("No se puede reversar préstamo, el asociado tiene una liquidación.");
            }
            
            $model->reversarComprobantePago();
            $model->reversarPrestamosAnteriores();
            $model->reversarCuotasTablaAmortizacion();

            $this->reversarRetirosParciales($pagoMasivoDetalle);
        }
    }

    private function reversarRetirosParciales($pagoMasivoDetalle)
    {
        EstatusRetiroParcial::model()->updateAll(['actual' => false], 'id_retiro_parcial=:id', ['id' => $pagoMasivoDetalle->id_proceso]);

        $model = new EstatusRetiroParcial();
        $model->id_retiro_parcial = $pagoMasivoDetalle->id_proceso;
        $model->id_estatus_retiro = 2;
        $model->observacion = $this->observacion;

        if (! $model->validate()) {
            throw new Exception('Error al validar retiro parcial.');
        }

        if (! $model->save()) {
            throw new Exception('Error al guardar retiro parcial.');
        }
    }

    private function reversarNominaPagoMasivo()
    {
        PagosMasivosSeguimiento::model()->updateAll(['actual' => false],
            'id_pagos_masivos=:id_pagos_masivos',
            ['id_pagos_masivos' => $this->id]
        );

        $model = new PagosMasivosSeguimiento();
        $model->id_estatus_pagos = 1;
        $model->id_pagos_masivos = $this->id;
        $model->observacion = $this->observacion;

        if (! $model->save()) {
            throw new Exception('No se pudo actualizar el seguimiento del pago masivo.');
        }
    }

    private function reversarComprobantesDePago()
    {
        if ($this->countPagos() == 0) {
            return;
        }

        Yii::app()->getDb()->createCommand('
            update contable.proceso_pago set actual=false, blnborrado=true
            from (
                select id_proceso
                from pagos.pagos_masivos_detalle pmd
                where pmd.id_pagos_masivos=:pago_masivo and blnborrado is false
            ) as data
            where data.id_proceso=proceso_pago.id_proceso and proceso_pago.blnborrado=false AND proceso_pago.actual=true
        ')->bindValues([
            'pago_masivo' => $this->id
        ])->query();
    }
}