<?php

namespace Predial\Http\Controllers;

use Predial\ParametrizacionAnio;
use Predial\ComprobanteCnt;
use Predial\ComprobantePptal;
use Predial\DetalleComprobanteCnt;
use Predial\DetalleComprobantePptal;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class RelacionPredialContableController extends Controller{

    public static function buscarTipoComprobante(){
        try {
            $data = DB::table('gf_tipo_comprobante')->where('interfaz_predial', '=', 1)->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function buscarCentroCosto(){
        try {
            $data = DB::table('gf_centro_costo')->where('nombre', '=', 'Varios')->where('parametrizacionanno', '=', session()->get('anno'))->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function datosPago($pago){
        try {
            $data = DB::table('gr_detalle_pago_predial as dpp')
                        ->select('fc.numero as numfac', 'p.codigo_catastral as codigo_catastral', 'pr.nombres as propietario', 'pg.fechapago as fecha', 'pg.banco', 'pg.tipopago as tipo')
                        ->leftJoin('gr_pago_predial as pg', 'dpp.pago', '=', 'pg.id_unico')
                        ->leftJoin('gr_detalle_factura_predial as dfp', 'dpp.detallefactura', '=', 'dfp.id_unico')
                        ->leftJoin('gr_factura_predial as fc', 'dfp.factura', '=', 'fc.id_unico')
                        ->leftJoin('gp_predio1 as p', 'fc.predio', '=', 'p.id_unico')
                        ->leftJoin('gp_tercero_predio as tp', 'p.id_unico', '=', 'tp.predio')
                        ->leftJoin('gr_propietarios as pr', 'tp.tercero', '=', 'pr.id_unico')
                        ->where('dpp.pago', '=', $pago)
                        ->where('tp.propietario', '=', '0')
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function consecutivoPredial($tipo, $param){
        try {
            $data = DB::table('gf_comprobante_cnt')->where('tipocomprobante', '=', $tipo)->where('parametrizacionanno', '=', $param)->max('numero');
            $param = ParametrizacionAnio::find($param);
            if(empty($data)){
                $numero = $param->anno."00001";
            }else{
                $numero = $data + 1;
            }
            return $numero;
        } catch (Exception $e) {
            $e->getMessage();
        }
    }

    public static function consecutivoPredialPptal($tipo, $param){
        try {
            $data = DB::table('gf_comprobante_pptal')->where('tipocomprobante', '=', $tipo)->where('parametrizacionanno', '=', $param)->max('numero');
            $param = ParametrizacionAnio::find($param);
            if(empty($data)){
                $numero = $param->anno."000001";
            }else{
                $numero = $data + 1;
            }
            return $numero;
        } catch (Exception $e) {
            $e->getMessage();
        }
    }

    public static function guardarCnt($numero, $fecha, $descripcion, $tipo, $param, $tercero, $estado, $compania){
        try {
            $new                      = new ComprobanteCnt();
            $new->numero              = $numero;
            $new->fecha               = $fecha;
            $new->descripcion         = $descripcion;
            $new->tipocomprobante     = $tipo;
            $new->parametrizacionanno = $param;
            $new->tercero             = $tercero;
            $new->estado              = $estado;
            $new->compania            = $compania;
            $new->save();
            return RelacionPredialContableController::obtenerUltimoComprobante($tipo, $numero);
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function guardarPptal($numero, $fecha, $descripcion, $param, $tipo, $tercero, $estado, $responsable){
        try {
            $new                      = new ComprobantePptal();
            $new->numero              = $numero;
            $new->fecha               = $fecha;
            $new->fechavencimiento    = $fecha;
            $new->descripcion         = $descripcion;
            $new->parametrizacionanno = $param;
            $new->tipocomprobante     = $tipo;
            $new->tercero             = $tercero;
            $new->estado              = $estado;
            $new->responsable         = $responsable;
            $new->save();
            return RelacionPredialContableController::obtenerUltimoComprobantePtal($tipo, $numero);
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerUltimoComprobante($tipo, $numero){
        $data = DB::table('gf_comprobante_cnt')->where('tipocomprobante', '=', $tipo)->where('numero', '=', $numero)->max('id_unico');
        return $data;
    }

    public static function obtenerUltimoComprobantePtal($tipo, $numero){
        $data = DB::table('gf_comprobante_pptal')->where('tipocomprobante', '=', $tipo)->where('numero', '=', $numero)->max('id_unico');
        return $data;
    }

    public static function obtenerDetallesPago($pago){
        try {
            $data = DB::select("SELECT DISTINCT dpp.id_unico ,cp.id_concepto, cp.anno, dpp.valor,p.tipo_predio
                                FROM            gr_detalle_pago_predial    as dpp
                                LEFT JOIN       gr_detalle_factura_predial as dfp ON dpp.detallefactura = dfp.id_unico
                                LEFT JOIN       gr_concepto_predial        as cp  ON dfp.concepto       = cp.id_unico
                                LEFT JOIN       gr_factura_predial         as f   ON f.id_unico=dfp.factura
                                LEFT JOIN       gp_predio1                 as p ON p.id_unico=f.predio
                                WHERE           dpp.pago   = $pago
                                AND             dpp.valor != 0 ");
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerConceptoRubroFuente($concepto, $anno, $param,$estrato){
        try {
            $data = DB::select("SELECT cf.concepto_financiero, cf.rubro_fuente,cf.porcentaje
                                FROM gf_configuracion_predial as cf
                                LEFT JOIN gf_vigencias_interfaz_predial as v ON cf.vigencia=v.id_unico
                                WHERE cf.concepto_predial=$concepto
                                AND v.valor= $anno
                                AND cf.tipo_predio=$estrato
                                AND v.parametrizacionanno=$param");
            return $data;

        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerConceptoRubroFuenteT($concepto, $param,$estrato){
        try {
            $data = DB::select("SELECT cf.concepto_financiero, cf.rubro_fuente,cf.porcentaje
                                FROM gf_configuracion_predial as cf
                                LEFT JOIN gf_vigencias_interfaz_predial as v ON cf.vigencia=v.id_unico
                                WHERE cf.concepto_predial=$concepto
                                AND v.parametrizacionanno=$param
                                AND cf.tipo_predio=$estrato
                                AND v.vigencias_anteriores=1");
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function guardarDetalleCnt($fecha, $valor, $comprobante, $naturaleza, $cuenta, $tercero, $proyecto, $centrocosto, $detallecomprobantepptal){
        try {
            $new                          = new DetalleComprobanteCnt();
            $new->fecha                   = $fecha;
            $new->valor                   = $valor;
            $new->comprobante             = $comprobante;
            $new->naturaleza              = $naturaleza;
            $new->cuenta                  = $cuenta;
            $new->tercero                 = $tercero;
            $new->proyecto                = $proyecto;
            $new->centrocosto             = $centrocosto;
            $new->detallecomprobantepptal = $detallecomprobantepptal;
            $new->save();
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function guardarDetalleCntCsa($fecha, $valor, $comprobante, $naturaleza, $cuenta, $tercero, $proyecto, $centrocosto, $detalleafectado){
        try {
            $new                  = new DetalleComprobanteCnt();
            $new->fecha           = $fecha;
            $new->valor           = $valor;
            $new->comprobante     = $comprobante;
            $new->naturaleza      = $naturaleza;
            $new->cuenta          = $cuenta;
            $new->tercero         = $tercero;
            $new->proyecto        = $proyecto;
            $new->centrocosto     = $centrocosto;
            $new->detalleafectado = $detalleafectado;
            $new->save();
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function guardarDetalleCntBanco($fecha, $valor, $comprobante, $naturaleza, $cuenta, $tercero, $proyecto, $centrocosto){
        try {
            $new                  = new DetalleComprobanteCnt();
            $new->fecha           = $fecha;
            $new->valor           = $valor;
            $new->comprobante     = $comprobante;
            $new->naturaleza      = $naturaleza;
            $new->cuenta          = $cuenta;
            $new->tercero         = $tercero;
            $new->proyecto        = $proyecto;
            $new->centrocosto     = $centrocosto;
            $new->save();
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function actualizarDetalleCnt($comprobante, $cuenta, $valor){
        try {
            $data = DB::table("gf_detalle_comprobante")
                        ->where('comprobante', '=', $comprobante)
                        ->where('cuenta', '=', $cuenta)
                        ->update(["valor" => $valor]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerUltimoDetalleCnt($comprobante){
        try {
            $data = DB::table('gf_detalle_comprobante')->where('comprobante', '=', $comprobante)->max('id_unico');
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function guardarDetallePtal($valor, $ptal, $conceptorubro, $tercero, $proyecto, $rubrofuente){
        try {
            $new                   = new DetalleComprobantePptal();
            $new->valor            = $valor;
            $new->comprobantepptal = $ptal;
            $new->conceptorubro    = $conceptorubro;
            $new->tercero          = $tercero;
            $new->proyecto         = $proyecto;
            $new->rubrofuente      = $rubrofuente;
            $new->save();
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function actualizarDetallePtal($comprobante, $conceptorubro, $rubrofuente, $valor){
        try {
            $data = DB::table('gf_detalle_comprobante_pptal')
                        ->where('comprobantepptal', '=', $comprobante)
                        ->where('conceptorubro', '=', $conceptorubro)
                        ->where('rubrofuente', '=', $rubrofuente)
                        ->update(["valor" => $valor]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerUltimoDetallePptal($comprobante, $rubro, $concepto){
        try {
            $data = DB::table('gf_detalle_comprobante_pptal')
            ->where('comprobantepptal', '=', $comprobante)
            ->where('rubrofuente', '=', $rubro)
            ->where('conceptorubro', '=', $concepto)
            ->max('id_unico');
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerConfiguracionCuenta($concepto_rubro){
        try {
            $data = DB::table('gf_concepto_rubro_cuenta as crc')
                        ->select('cd.id_unico as ctaD', 'cd.naturaleza as natD', 'cc.id_unico as ctaC', 'cc.naturaleza as natC')
                        ->leftJoin('gf_cuenta as cd', 'crc.cuenta_debito', '=', 'cd.id_unico')
                        ->leftJoin('gf_cuenta as cc', 'crc.cuenta_credito','=', 'cc.id_unico')
                        ->where('crc.concepto_rubro', '=', $concepto_rubro)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerValorCuentaComprobante($comprobante, $cuenta){
        try {
            $data = DB::table('gf_detalle_comprobante')
                        ->select('valor')
                        ->where('comprobante', '=', $comprobante)
                        ->where('cuenta', '=', $cuenta)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function actualizarDetallePagoRelacion($id_unico, $detalle){
        try {
            $data = DB::table("gr_detalle_pago_predial")
                        ->where("id_unico", '=', $id_unico)
                        ->update(["detallecomprobante" => $detalle]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerCuentaBanco($banco){
        try {
            $data = DB::table("gf_cuenta_bancaria as cb")
                        ->select("cb.cuenta", "c.naturaleza")
                        ->leftJoin("gf_cuenta as c", "cb.cuenta", "=", "c.id_unico")
                        ->where('cb.id_unico', '=', $banco)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function eliminarcomprobanteCnt($id_unico){
        try {
            $data = ComprobanteCnt::findOrFail($id_unico);
            $data->delete();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function eliminarcomprobantePtal($id_unico){
        try {
            $data = ComprobantePptal::findOrFail($id_unico);
            $data->delete();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerDataComprobante($comprobante, $cuenta){
        try {
            $data = DB::table('gf_detalle_comprobante')
                        ->select('valor')
                        ->where('comprobante', '=', $comprobante)
                        ->where('cuenta', '=', $cuenta)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function obtenerDataComprobantePtal($comprobante, $conceptorubro, $rubrofuente){
        try {
            $data = DB::table('gf_detalle_comprobante_pptal')
                        ->select('valor')
                        ->where('comprobantepptal', '=', $comprobante)
                        ->where('conceptorubro', '=', $conceptorubro)
                        ->where('rubrofuente', '=', $rubrofuente)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function procesarRelacion($pago){
        $param = session()->get('anno');
        $compa = session()->get('compania');
        $tipod = RelacionPredialContableController::buscarTipoComprobante();
        $tipoCnt  = $tipod->id_unico;
        $tipoPtal = $tipod->comprobante_pptal;
        $tipoCsa  = $tipod->tipo_comp_hom;
        $centroC  = RelacionPredialContableController::buscarCentroCosto();

        $dataComp = RelacionPredialContableController::datosPago($pago);
        if($dataComp->tipo == 1 OR $dataComp->tipo == 7 OR $dataComp->tipo == 4){
            $numero   = RelacionPredialContableController::consecutivoPredial($tipoCnt, $param);

            $descripcion = 'Comprobante de Recaudo Predial Factura N°:'.$dataComp->numfac.' Predio:'.$dataComp->codigo_catastral.' Propietario: '.utf8_encode($dataComp->propietario);
            $descCsc     = 'Comprobante de Causación Recaudo Predial Factura N°:'.$dataComp->numfac.' Predio:'.$dataComp->codigo_catastral.' Propietario: '.utf8_encode($dataComp->propietario);
            $fecha       = $dataComp->fecha;

            $cnt = RelacionPredialContableController::guardarCnt($numero, $fecha, $descripcion, $tipoCnt, $param, 2, 1, $compa);
            $ppt = "";
            $csa = "";
            if(!empty($tipoPtal)){
                $numeroP = RelacionPredialContableController::consecutivoPredialPptal($tipoPtal, $param);
                $ppt     = RelacionPredialContableController::guardarPptal($numero, $fecha, $descripcion, $param, $tipoPtal, 2, 1, 2);
            }

            if(!empty($tipoCsa)){
                $numeroC = RelacionPredialContableController::consecutivoPredial($tipoCsa, $param);
                $csa     = RelacionPredialContableController::guardarCnt($numero, $fecha, $descCsc, $tipoCsa, $param, 2 , 1, $compa);
            }
            if(!empty($cnt)){
                $data_pago = RelacionPredialContableController::obtenerDetallesPago($pago);
                $arrayConcepto  = array();
                $arrayRubro     = array();
                $arrayCuentaD   = array();
                $arrayCuentaDC  = array();
                $arrayCuentaCC  = array();
                $totalD = 0;
                $totalC = 0;
                $c      = 0;
                foreach ($data_pago as $row) {
                    $detalle = $row->id_unico;
                    $valor   = $row->valor;
                    $vig     = RelacionPredialContableController::obtenerConceptoRubroFuente($row->id_concepto, $row->anno, $param,$row->tipo_predio);

                    if(empty($vig)){
                        $vig = RelacionPredialContableController::obtenerConceptoRubroFuenteT($row->id_concepto, $param,$row->tipo_predio);
                    }

                    if(!empty($vig)){

                    foreach ($vig as $rowV) {

                        $conceptoFinanciero = $rowV->concepto_financiero;
                        $rubroFuente        = $rowV->rubro_fuente;
                        $porcentaje         = $rowV->porcentaje;
                        $valor              = $row->valor;

                        if(!empty($conceptoFinanciero) && !empty($rubroFuente)){
                            $c++;
                            
                                $valor =  ROUND(($valor*$porcentaje)/100);
                                $ins = RelacionPredialContableController::guardarDetallePtal($valor, $ppt, $conceptoFinanciero, 2, 2147483647, $rubroFuente);
                                array_push($arrayRubro, $rubroFuente);
                                array_push($arrayConcepto, $conceptoFinanciero);
                            


                            $id_detalle_p = RelacionPredialContableController::obtenerUltimoDetallePptal($ppt, $rubroFuente, $conceptoFinanciero);
                            $crc          = RelacionPredialContableController::obtenerConfiguracionCuenta($conceptoFinanciero);
                            if(!empty($crc) > 0){
                                $ctaDto = $crc->ctaD; $ctaCto = $crc->ctaC;
                                $natDto = $crc->natD; $natCto = $crc->natC;
                               


                                if($natDto ==1){
                                    if($valor>0){
                                        $valor = $valor*-1;
                                        $totalC +=$valor*-1;
                                    } else {
                                        $totalD +=$valor*-1;
                                        $valor = $valor*-1;
                                    }
                                } else {
                                    if($valor>0){
                                        $totalC +=$valor;
                                    } else {
                                        $totalD +=$valor*-1;
                                        $valor = $valor;
                                    }
                                }


                                    array_push($arrayCuentaD ,$ctaDto);
                                    $ins = RelacionPredialContableController::guardarDetalleCnt($fecha, $valor, $cnt, $natDto, $ctaDto, 2, 2147483647, $centroC->id_unico, $id_detalle_p);
                                
                                /**** Detalles de Causaicón ****/
                                $id_detalle_c = RelacionPredialContableController::obtenerUltimoDetalleCnt($cnt);
                                if($ctaDto != $ctaCto){
                                    if(!empty($tipoCsa)){
                                        $valorDE =  ROUND(($valor*$porcentaje)/100);

                                        if($natDto == 1){
                                            $valorD = ($valorDE)*-1;
                                        }else{
                                            $valorD = $valorDE;
                                        }

                                            array_push ($arrayCuentaDC ,$ctaDto);
                                            $ins = RelacionPredialContableController::guardarDetalleCntCsa($fecha, $valorD, $csa, $natDto, $ctaDto, 2, 2147483647, $centroC->id_unico, $id_detalle_c);
                                    
                                        $valorCE =  ROUND(($valor*$porcentaje)/100);
                                        if($natCto == 1){
                                          $valorC = $valorCE;
                                        }else{
                                          
                                          $valorC = $valorCE * -1;
                                        }


                                            array_push ($arrayCuentaCC ,$ctaCto);
                                            $ins = RelacionPredialContableController::guardarDetalleCntCsa($fecha, $valorC, $csa, $natCto, $ctaCto, 2, 2147483647, $centroC->id_unico, $id_detalle_c);
                            
                                    }
                                }
                                $update_pago  = RelacionPredialContableController::actualizarDetallePagoRelacion($detalle, $id_detalle_c);
                            }
                        }
                     }
                    }
                
                }
                $dta_Banco = RelacionPredialContableController::obtenerCuentaBanco($dataComp->banco);
                $ctaBanco  = $dta_Banco->cuenta;
                $natBanco  = $dta_Banco->naturaleza;
                $valorB    = $totalC - $totalD;

                if($natBanco == 1){
                    if($valorB > 0){
                        $valorB = $valorB;
                    }else{
                        $valorB = $valorB * -1;
                    }
                }else{
                    if($valorB > 0){
                        $valorB = $valorB * -1;
                    }else{
                        $valorB = $valorB;
                    }
                }

                if($dataComp->tipo == 7){
                    $valorB = $valorB * -1;
                    $ins = RelacionPredialContableController::guardarDetalleCntBanco($fecha, $valorB, $cnt, $natBanco, $ctaBanco, 2, 2147483647, $centroC->id_unico, "NULL");
                }else{
                    $ins = RelacionPredialContableController::guardarDetalleCntBanco($fecha, $valorB, $cnt, $natBanco, $ctaBanco, 2, 2147483647, $centroC->id_unico, "NULL");
                }

                $dataCsa = ComprobanteCnt::find($csa);
                if(!empty($dataCsa) < 0){
                    $xc  = RelacionPredialContableController::eliminarcomprobanteCnt($csa);
                }
            }
        }
    }
}