<?php

namespace Predial\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Response;
use Predial\Area;
use Predial\DetalleResolucion;
use Predial\Resolucion;
use Predial\EstadoResolucion;
use Maatwebsite\Excel\Facades\Excel;
use Predial\Predio;
use Predial\Propietario;
use Predial\PropietarioPredio;
use Predial\Avaluo;

class ResolucionController extends Controller{

    public $path = "resolucion.";

    /**
     * Index
     * @author Alexander Numpaque
     * @package Predial
     * @return view $this->path."index" Vista de inicio
     */
    public function index(){
        if(!empty(session()->get('usuario'))){
            $data = DB::table("gr_resolucion as res")
                        ->select(
                            'res.id_unico',
                            'res.nombre',
                            'res.numero',
                            'res.ruta',
                            'res.observaciones',
                            'est.nombre as estado',
                            DB::raw("date_format(fecha, '%d/%m/%Y') as fecha")
                        )
                      ->leftJoin('gr_estado_resolucion as est','res.estado','=','est.id_unico')
                      ->get();
            return view($this->path."index")->with('data', $data);
        }else{
            return redirect("CerrarSesion");
        }
    }

    /**
     * Create
     * @author Alexander Numpaque
     * @package Predial
     * @return view $this->path."create" Vista de registro de resolucion
     */
    public function create(){
        $estados = EstadoResolucion::all();
        return view($this->path."create")->with('estados', $estados);
    }

    /**
     * store
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request
     * @return redirect ListarResolucion Listado de Resoluciones
     */
    public function store(Request $request){
        try {
            $ff    = explode("/", $request->txtFecha);
            $fecha = "$ff[2]-$ff[1]-$ff[0]";

            $new = new Resolucion();
            $new->nombre = $request->txtNombre;
            $new->numero = $request->txtNumero;
            $new->fecha  = $fecha;
            if(empty($request->file('txtRuta'))){
            }else{
                $file = $request->file('txtRuta');
                $mine = $request->file('txtRuta')->getMimeType();
                $name = $request->file('txtRuta')->getClientOriginalName();
                $xtsn = strtolower($request->file('txtRuta')->getClientOriginalExtension());
                $pth  = "docs/resoluciones";
                $loc  = $pth."/".$name;
                $request->file("txtRuta")->move($pth, $name);
                $new->ruta = $loc;
            }

            $new->observaciones = $request->txtObservaciones;
            $new->estado        = $request->sltEstado;
            $new->save();

            flash()->overlay('Información registrada correctamente.','Información');
            return redirect('ListarResolucion');
        } catch (Exception $e) {
            return "Fatal error = ".$e->getMessage();
        }
    }

    public function show(){}

    /**
     * edit
     * Metodo para mostrar el formulario de modificación
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id_unico Id de la resolución
     * @return View Edit Vista de edición
     */
    public function edit($id_unico){
        if(!empty(session()->get('usuario'))){
            $id      = decrypt($id_unico);
            $data    = DB::table("gr_resolucion as res")
                        ->select(
                            'res.id_unico',
                            'res.nombre',
                            'res.numero',
                            'res.ruta',
                            'res.observaciones',
                            'est.nombre as estado',
                            'est.id_unico as id_estado',
                            DB::raw("date_format(fecha, '%d/%m/%Y') as fecha")
                        )
                      ->leftJoin('gr_estado_resolucion as est','res.estado','=','est.id_unico')
                      ->where('res.id_unico','=',$id)
                      ->first();
            $estado  = EstadoResolucion::find($data->id_estado);

            $estados = DB::table('gr_estado_resolucion')
                           ->select('id_unico', 'nombre')
                           ->where('id_unico', '!=', $data->id_estado)
                           ->get();
            return view($this->path."edit")
                    ->with('data', $data)
                    ->with('estado', $estado)
                    ->with('estados', $estados);
        }else{
            return redirect("CerrarSesion");
        }
    }

    /**
     * Update
     * Proceso para actualizar los datos de la resolución
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request Envio del formulario
     * @return redirect Retorna a la vista Listado de Resoluciones
     */
    public function update(Request $request){
        try {
            $ff    = explode("/", $request->txtFecha);
            $fecha = "$ff[2]-$ff[1]-$ff[0]";

            $data = Resolucion::find($request->id_unico);

            $upd  = Resolucion::findOrFail($request->id_unico);

            $upd->nombre = $request->txtNombre;
            $upd->numero = $request->txtNumero;
            $upd->fecha  = $fecha;

            if(empty($request->file('txtRuta'))){
                $upd->ruta = $data->ruta;
            }else{
                if(\File::exists(public_path($data->ruta))){
                    \File::delete(public_path($data->ruta));
                }
                $file = $request->file('txtRuta');
                $mine = $request->file('txtRuta')->getMimeType();
                $name = $request->file('txtRuta')->getClientOriginalName();
                $xtsn = strtolower($request->file('txtRuta')->getClientOriginalExtension());
                $pth  = "docs/resoluciones";
                $loc  = $pth."/".$name;

                $request->file("txtRuta")->move($pth, $name);

                $upd->ruta = $loc;
            }

            $upd->observaciones = $request->txtObservaciones;
            $upd->estado        = $request->sltEstado;
            $upd->save();

            flash()->overlay('Información modificada correctamente', 'Información');
            return redirect('ListarResolucion');
        } catch (Exception $e) {
            return "Fatal error = ".$e->getMessage();
        }
    }

    /**
     * Destroy
     * Metodo para eliminar la resolución
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id_unico Id de la resolución
     * @return redirect Retorna a la vista listado de resoluciones
     */
    public function destroy($id_unico){
        try {
            $id   = decrypt($id_unico);
            $data = Resolucion::find($id);
            if(\File::exists(public_path($data->ruta))){
                \File::delete(public_path($data->ruta));
            }

            $del = Resolucion::findOrFail($id);
            $del->delete();

            flash()->overlay('Información eliminad correctamente', 'Información');
            return redirect('ListarResolucion');
        } catch (Exception $e) {
            return "Fatal error".$e->getMessage();
        }
    }

    /**
     * opendetails
     * Metodo para mostrar el formualrio de registro de detalles
     * @author Alexander Numpaque
     * @package Predial
     * @param int $res Id de resolución
     * @return View Vista de detalles
     */
    public function opendetails($res){
        $id = decrypt($res);
        $dd = Resolucion::find($id);
        return view('resolucion.detalles', compact('dd'));
    }

    /**
     * storeDetails
     * Metodo para guardado de detalles
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request
     * @return View vista de registro de detalles
     */
    public static function storeDetails(Request $request){
        try {
            $id = decrypt($request->txtResolucion);
            $ff = explode("/", $request->txtFecha);
            $fecha = !empty($request->txtFecha)?"$ff[2]-$ff[1]-$ff[0]":"";
            $detalle                     = new DetalleResolucion();
            $detalle->resolucion         = $id;
            $detalle->articulo           = $request->txtArticulo;
            $detalle->cm                 = $request->txtCM;
            $detalle->numero_mutacion    = $request->txtNrMut;
            $detalle->estado             = $request->txtCI;
            $detalle->codigo_catastral   = $request->txtNumero;
            $detalle->tdt                = $request->txtTDT;
            $detalle->nombre_propietario = $request->txtNombres;
            $detalle->ec                 = $request->txtEC;
            $detalle->tipodocumento      = $request->txtTD;
            $detalle->numerodoc          = $request->txtDoc;
            $detalle->orden_propietario  = $request->txtPROP;
            $detalle->direccion          = $request->txtDireccion;
            $detalle->des                = $request->txtDes;
            $detalle->hectarea           = $request->txtHectarea;
            $detalle->metros_c           = $request->txtMetros;
            $detalle->area_cons          = $request->txtAreaC;
            $detalle->avaluo             = $request->txtAvaluo;
            $detalle->vigencia           = $request->txtVigencia;
            $detalle->npn                = $request->txtNP;
            $detalle->descripcion        = $request->txtDescripcion;
            $detalle->fecha              = $fecha;
            $detalle->anno               = $request->txtAno;
            $detalle->cod_padre          = $request->txtCodPadre;
            $detalle->save();

            flash()->overlay("Información guardada correctamente.", 'Información');
            return back();
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * viewDataDetails
     * Vista para ver los datos registrados en la resolución
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id Id de la resolución
     * @return view ViewDetails Vista de los detalles
     */
    public static function viewDataDetails($id){
        $id = decrypt($id);
        $dd = Resolucion::find($id);
        $data = DB::table('gr_detalle_resolucion')->where('resolucion', '=', $id)->get();
        return view('resolucion.ViewDetails', compact('dd', 'data'));
    }

    /**
     * lookUpResId
     * Metodo para buscar los datos de las resoluciones
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request Envio del formulario
     * @return Collection|Array $data
     */
    public static function lookUpResId($id){
        try {
            $data = DB::table('gr_detalle_resolucion')
                        ->where('resolucion', '=', $id)
                        ->orderBy('id_unico')
                        ->get();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpResPre
     * Buscamos los cambios que existen en el predio
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request
     * @return Collection $data
     */
    public static function lookUpResPre($id, $cod){
        try {
            $data = DB::table('gr_detalle_resolucion')
                        ->where('resolucion', '=', $id)
                        ->where('codigo_catastral', '=', $cod)
                        ->get();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * cacthinfo
     * Metodo para capturar y validar si la resolución tiene detalles
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request Envio get
     * @return String $html Estructura de html creada atravez del llamado de la función buidlform
     */
    public static function cacthinfo(Request $request){
        $res  = $request->id; $cod_p = $request->cod;
        $data = ResolucionController::lookUpResId($res);
        if(count($data) > 0){
            $html = ResolucionController::buildform($data, $res);
        }else{
            $html = "<h3 class='text-center'>No hay detalles de la resolucion</h3>";
        }
        return $html;
    }

    /**
     * buidlform
     * Metodo para costruir tabla dinamica para los detalles de la resoluciones
     * @author Alexander Numpaque
     * @package Predial
     * @param Array $inf Detalles de la resolución
     * @param int $id Id de la resolución
     * @return String $html Estructura de la tabla
     */
    public static function buildform($inf, $id){
        $html = "";
        $html .= "\n<div style='height: 380px !important; overflow-y: auto; margin-bottom: 0px' class='scrollbar-info'>";
        $html .= "\n\t<table style='with: 100%' class='table-bordered table-striped'>";
        $html .= "\n\t\t<thead>";
        $html .= "\n\t\t\t<tr>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' rowspan='2'>ARTICULO</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' rowspan='2'>CM</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' rowspan='2'>NRO<br/>MUTACIÓN</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' rowspan='2'>ESTADO</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' rowspan='2'>NRO<br/>PREDIO</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>TDT</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' colspan='2'>APELLIDOS Y <br/> NOMBRES</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>EC</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>TD</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>NRO DOC</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle' colspan='2'>CATASTRO</th>";
        $html .= "\n\t\t\t</tr>";
        $html .= "\n\t\t\t<tr>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>PROP</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>DIRECCION</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>DES</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>HECT</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>MET<sup>2</sup></th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>A-CONS</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>AVALUO</th>";
        $html .= "\n\t\t\t\t<th class='text-center align-middle'>VIGENCIA</th>";
        $html .= "\n\t\t\t</tr>";
        $html .= "\n\t\t</thead>";
        $html .= "\n\t\t<tbody>";
        $x = 0;
        foreach ($inf as $value) {
            $html .= "\n\t\t\t<tr>";
            $x++;
            if(!empty($value->articulo)){
                $html .= ResolucionController::structHtml("articulo", $value->articulo, $x, 40, FALSE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
            }
            if(!empty($value->cm)){
                $html .= ResolucionController::structHtml("CM", $value->cm, $x, 40, FALSE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
            }
            if(!empty($value->numero_mutacion)){
                $html .= ResolucionController::structHtml("NumeroMutacion", $value->numero_mutacion, $x, 50, FALSE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
            }
            if(!empty($value->estado)){
                $html .= ResolucionController::structHtml("CI", $value->estado, $x, 40, FALSE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
            }
            if(!empty($value->codigo_catastral)){
                $html .= ResolucionController::structHtml("Codigo Catastral", $value->codigo_catastral, $x, 110, TRUE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
            }
            if(!empty($value->tdt)){
                $html .= ResolucionController::structHtml("TDT", $value->tdt, $x, 60, FALSE);
            }else{
                if(!empty($value->orden_propietario)){
                    $html .= ResolucionController::structHtml("PROP", $value->orden_propietario, $x, 60, TRUE);
                }else{
                    $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
                }
            }
            if(!empty($value->nombre_propietario)){
                $html .= ResolucionController::structHtml("Nombres", $value->nombre_propietario, $x, 200, TRUE);
            }else{
                if(!empty($value->direccion)){
                    $html .= ResolucionController::structHtml("Direccion", $value->direccion, $x, 200, TRUE);
                }else{
                    $html .= ResolucionController::structHtml("Descripcion", $value->descripcion, $x, 200, FALSE);
                    if(!empty($value->cod_padre)){
                        $html .= ResolucionController::structHidden("Padre", $value->cod_padre, $x);
                    }
                }
            }
            if(!empty($value->des)){
                $html .= ResolucionController::structHtml("DES", $value->des, $x, 40, TRUE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x,  0, FALSE);
            }
            if(!empty($value->ec)){
                $html .= ResolucionController::structHtml("EC", $value->ec, $x, 90, TRUE);
            }else{
                $html .= ResolucionController::structHtml("Hectarea", (float) $value->hectarea, $x, 90, TRUE);
            }
            if(!empty($value->tipodocumento)){
                $html .= ResolucionController::structHtml("TipoDoc", $value->tipodocumento, $x, 90, TRUE);
            }else{
                $html .= ResolucionController::structHtml("MetrosC", (float) $value->metros_c, $x, 90, TRUE);
            }
            if(!empty($value->numerodoc)){
                $html .= ResolucionController::structHtml("Documento", str_pad($value->numerodoc, 12, '0', STR_PAD_LEFT), $x, 100, TRUE);
            }else{
                $html .= ResolucionController::structHtml("AreaCons", (float) $value->area_cons, $x, 100, TRUE);
            }
            if(!empty($value->avaluo)){
                $html .= ResolucionController::structHtml("Avaluo", (float) $value->avaluo, $x, 150, TRUE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x, 0, FALSE);
            }
            if(!empty($value->vigencia)){
                $html .= ResolucionController::structHtml("Vigencia", $value->vigencia, $x, 100, TRUE);
            }else{
                $html .= ResolucionController::structHtml("none", "", $x, 0, FALSE);
            }
            $html .= "\n\t\t\t</tr>";
        }
        $html .= ResolucionController::structHidden("Cantidad", $x, 0);
        $html .= ResolucionController::structHidden("Resolucion", encrypt($id), 0);
        $html .= "\n\t\t</tbody>";
        $html .= "\n\t</table>";
        $html .= "\n</div>";
        return $html;
    }

    /**
     * structHtml
     * Metodo para estructurar y validar si el campo de la tabla tiene input o no
     * @author Alexander Numpaque
     * @package Predial
     * @param String $nlabel Nombre del campo
     * @param String $value Valor del campo
     * @param int $i Contador
     * @param int|null $width Ancho del campo
     * @param bool $input Variable para validar si se incluye input text o solo el valor
     * @return String $xhtml Estructura html para complementar la tabla
     */
    public static function structHtml($nlabel, $value, $i, $width = NULL, $input){
        $name  = ResolucionController::deleteSpaces($nlabel);
        $xhtml = "";
        $value = is_float($value)?number_format($value, 0, ',', '.'):$value;
        if(!empty($value)){
            $xhtml .= "\n\t\t\t<td>";
            // $xhtml .= "\n\t\t\t\t<input type='text' name='txt$name".'[]'."' id='txt$name$i' class='form-control' value='$value' style='font-size:10;margin-top: 0px; margin-bottom: 5px; width: ".$width."px' />";
            if($input == TRUE){
                $xhtml .= "\n\t\t\t\t<input type='text' name='txt$name$i' id='txt$name$i' class='form-control' value='$value'     style='font-size:10;margin-top: 0px; margin-bottom: 5px; width: ".$width."px' />";
            }else{
                $xhtml .= $value;
            }
            $xhtml .= "\n\t\t\t</td>";
        }else{
            $xhtml .= "\n\t\t\t<td></td>";
        }
        return $xhtml;
    }

    /**
     * deleteSpaces
     * Metodo para quitar espacios en blancos
     * @author Alexander Numpaque
     * @package Predial
     * @param String $label Variable o nombre del campo
     * @return String $label Variable Sin espacion
     */
    public static function deleteSpaces($label){
        return str_replace(' ', '', $label);
    }

    /**
     * structHidden
     * Metodo para crear campos ocultos
     * @author Alexander Numpaque
     * @package Predial
     * @param String $nlabel Nombre del campo
     * @param String $value Valor del campo
     * @param String $i Contador
     * @return String $html Variable la cual contiene la estructura html
     */
    public static function structHidden($nlabel, $value, $i){
        $name  = ResolucionController::deleteSpaces($nlabel);
        $xhtml = "";
        // $xhtml .= "\n\t\t\t\t<input type='hidden' name='txt$name".'[]'."' id='txt$name$i' value='$value' />";
        if($i != 0){
            $xhtml .= "\n\t\t\t\t<input type='hidden' name='txt$name$i' id='txt$name$i' value='$value' />";
        }else{
            $xhtml .= "\n\t\t\t\t<input type='hidden' name='txt$name' id='txt$name' value='$value' />";
        }
        return $xhtml;
    }

    /**
     * quitPointer
     * Metodo para quitar puntos en un String
     * @author Alexander Numpaque
     * @package Predial
     * @param String $value Valor
     * @return String $value sin puntos
     */
    public static function quitPointer($value){
        return str_replace('.', '', $value);
    }

    /**
     * lookUpPC
     * Metodo para bucar predio por codigo catastral
     * @author Alexander Numpaque
     * @package Predial
     * @param String $codC Codigo Catastral
     * @return Collection $data Valores obtenidos atraves de la consulta
     */
    public static function lookUpPC($codC){
        try {
            $data = DB::table('gp_predio1')
                        ->where('codigo_catastral', '=', $codC)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpPro
     * Metodo para buscar propietario por número de identificación
     * @author Alexander Numpaque
     * @package Predial
     * @param String $numero Número de identificación del propietario
     * @return Collection $data Valores obtenidos por consulta
     */
    public static function lookUpPro($numero, $direccion){
        try {
            $data = DB::table('gr_propietarios')
                        ->where('numero', '=', $numero)
                        ->where('direccion', '=', $direccion)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpTerp
     * Metodo para buscar los propietarios relacionados al predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @return Collection $data Datos obtenidos de base de datos
     */
    public static function lookUpTerp($predio){
        try {
            $data = DB::table('gp_tercero_predio')
                        ->where('predio', '=', $predio)
                        ->get();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpProId
     * Metodo para buscar propietario por id
     * @author Alexander Numpaque
     * @package Predial
     * @param String $id Id del propietario
     * @return Collection $data Valores obtenidos por consulta
     */
    public static function lookUpProId($id){
        try {
            $data = DB::table('gr_propietarios')
                        ->where('id_unico', '=', $id)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * saveProP
     * Metodo para guardar los datos en tercero predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param int $tercero Id del propietario
     * @param int $prop Indicador si el propietario 001
     * @param String $orden Ordenamiento de propietarios por el igac
     * @param int $porcentaje Cantidad de pertenencia del predio
     */
    public static function saveProP($predio, $tercero, $prop, $orden, $porcentaje){
        try {
            $data = DB::table('gp_tercero_predio')->insert(
                [
                    "predio"      => $predio,
                    "tercero"     => $tercero,
                    "propietario" => $prop,
                    "orden"       => $orden,
                    "porcentaje"  => $porcentaje
                ]
            );
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * processTer
     * Metodo para procesar los resultados de la función lookUpTerp,  y validar a la vez que el propietario
     * este relacionado al predio
     * @author Alexander Numpaque
     * @package Predial
     * @param Collection $data Data obtenida de la función lookUpTerp
     * @param String $numero de identificación del propietario
     * @return bool $bool Id del tercero encaso de estar relacioando al predio
     */
    public static function processTer($data, $numero){
        $bool = "";
        foreach ($data as $value) {
            $dd = ResolucionController::lookUpProId($value->tercero);
            if(count($dd) > 0){
                $bool = $dd->numero==$numero?$value->tercero:"";
            }
        }
        return $bool;
    }

    /**
     * lookUpTerOr
     * Metodo para buscar el propietario respecto a un orden y un predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param String $orden Ordenmiento del propietario respecto al igac
     * @return Collection $data Datos obtenidos por la consulta
     */
    public static function lookUpTerOr($predio, $orden){
        try {
            $data = DB::table("gp_tercero_predio")->where('predio', '=', $predio)->where('orden', '=', $orden)->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpTerOrPro
     * Metodo para buscar el propietario respecto a un orden y un predio y propietario
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param String $orden Ordenmiento del propietario respecto al igac
     * @return Collection $data Datos obtenidos por la consulta
     */
    public static function lookUpTerOrPro($predio, $orden, $pro){
        try {
            $data = DB::table("gp_tercero_predio")->where('predio', '=', $predio)->where('orden', '=', $orden)->where('tercero', '=', $tercero)->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * deleteTerOr
     * Metodo para eliminar la relación propietario predio respecto a un orden y un predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param int $tercero Id del propietario
     * @return bool|int $data  Retorna 1 o true cuando se ejecuta el proceso de eliminado
     */
    public static function deleteTerOr($predio, $tercero){
        try {
            $data = DB::table('gp_tercero_predio')->where('predio', '=', $predio)->where('tercero', '=', $tercero)->delete();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * deleteTerPre
     * Metodo para eliminar la relación propietario predio respecto a un orden y un predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param int $tercero Id del propietario
     * @return bool|int $data  Retorna 1 o true cuando se ejecuta el proceso de eliminado
     */
    public static function deleteTerPre($predio){
        try {
            $data = DB::table('gp_tercero_predio')->where('predio', '=', $predio)->delete();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * validateTypeDoc
     * Función para validar el tipo de documento del propietario a registrar
     * @author Alexander Numpaque
     * @package Predial
     * @param String $type tipo de documento dado por el igac
     * @return $int $tipo Valor de tipo documento respecto a la bd
     */
    public static function validateTypeDoc($type){
        $tipo = "";
        switch ($type) {
            case "X":
                $tipo = 6;
                break;
            case "N":
                $tipo = 2;
                break;
            case "C":
                $tipo = 1;
                break;
            default:
                $tipo = 1;
                break;
        }
        return $tipo;
    }

    /**
     * saveDataProp
     * Metodo para guardar los datos del propietario
     * @author Alexander Numpaque
     * @package Predial
     * @param String $nombres Nombre del propietario
     * @param int $tipo Tipo de identificación del propietario
     * @param String $numero Número de identificación
     * @param String $direccion Dirección del propietario
     * @return bool|int $data Si el valor es guardado retorna verdadero
     */
    public static function saveDataProp($nombres, $tipo, $numero, $direccion){
        try {
            $data = DB::table('gr_propietarios')
                       ->insert([
                            "nombres"            => $nombres,
                            "tipoidentificacion" => $tipo,
                            "numero"             => $numero,
                            "direccion"          => $direccion
                       ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * saveMutation
     * Guardar datos de Mutación en la tabla gr_resolución_predio
     * @author Alexander Numpaque
     * @package Predial
     * @param date $fecha Fecha de la resolución
     * @param int $resolucion Id de la resolución
     * @param int $predio Id del predio
     * @return bool|int Retorna verdadero si el valor se guardo en la base de datos
     */
    public static function saveMutation($fecha, $resolucion, $predio){
        try {
            $data = DB::table("gr_resolucion_predio")
                        ->insert([
                            "fecha"      => $fecha,
                            "resolucion" => $resolucion,
                            "predio"     => $predio
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * saveDetailMutation
     * Guardado en la table gr_concepto_resolucion como detalle de gr_resolucion_predio
     * @author Alexander Numpaque
     * @package Predial
     * @param String $lValue Valor anterior
     * @param String $nValue Valor nuevo
     * @param int $resPre Id de resolución predio
     * @param int $typeC Tipo de concepto
     * @param int $typeM tipo de modificación
     * @return bool $data Retorna verdadero cuando se inserta el valor
     */
    public static function saveDetailMutation($lValue, $nValue, $resPre, $typeC, $typeM){
        try {
            $data = DB::table('gr_concepto_resolucion')
                       ->insert([
                            "valoranterior"      => $lValue,
                            "valoractual"        => $nValue,
                            "resolucionconcepto" => $resPre,
                            "tipoconcepto"       => $typeC,
                            "tipomodificacion"   => $typeM
                       ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpD
     * Metodo para buscar o obtener el id del destino economico del predio por codigo
     * @author Alexander Numpaque
     * @package Predial
     * @param String $destino Codigo de destino
     * @return Collection $data Datos encontrados en la consulta
     */
    public static function lookUpD($destino){
        try {
            $destino = "$destino";
            $data = DB::table('gr_destino_economico')->where('codigo', '=', $destino)->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updateD
     * Metodo para actualizar el destino economico del predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param int $destino Id del destino economico
     * @return bool $data Retorna 1 o verdadero si se actualiza los datos en la bd
     */
    public static function updateD($predio, $destino){
        try {
            $data = DB::table('gp_predio1')->where('id_unico', '=', $predio)->update(['destino_economico' => $destino]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * getVigencia
     * Metodo para obtener el año en la vigencia valida
     * @author Alexander Numpaque
     * @package Predial
     * @param String $vigencia Vigencia formada 01012019 (diamesaño)
     * @return String $vigencia el año de la vigencia 2019
     */
    public static function getVigencia($vigencia){
        return  substr($vigencia, 4);
    }

    /**
     * lookUpA
     * Metodo para buscar area respecto a predio y año
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param String $anno Año
     * @return Collection $data Datos encontrados en la base de datos
     */
    public static function lookUpA($predio, $anno){
        try {
            $data = DB::table('gr_area')->where('predio', '=', $predio)->where('anio', '=', $anno)->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * deleteArea
     * Metodo para eliminar area por id
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id_unico Id unico del predio
     * @return bool $data Retorna verdadero si el valor es eliminado de la bd
     */
    public static function deleteArea($id_unico){
        try {
            $data = DB::table('gr_area')->where('id_unico', '=', $id_unico)->delete();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updateArea
     * Metodo para registrar o actualizar el area
     * @param int|double $hectarea Medida
     * @param int|double $metros Medida
     * @param int|double $area_cons Medida
     * @param int $predio Id del predio
     * @param String $anno Año
     * @return bool $data Retorna verdadero si los datos son registrados o actualizados
     */
    public static function updateArea($hectarea, $metros, $area_cons, $predio, $anno){
        try {
            $data = Area::updateOrCreate([
                            "valor"            => $hectarea,
                            "area_metros"      => $metros,
                            "area_construida"  => $area_cons,
                            "predio"           => $predio,
                            "anio"             => $anno,
                            "tipoarea"         => 1,
                            "unidadarea"       => 1,
                            "motivocambioarea" => 3
                        ])
                        ->where("predio", '=', $predio)
                        ->where("anio", "=", $anno);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * createArea
     * Metodo para crear area
     * @param double $hectarea Valor en hectareas
     * @param double $metros Valor en metros cuadrados
     * @param double $area_cons Valor de area construida
     * @param int $predio Id del predio
     * @param String $anno Año
     * @return Collection $data Si el registro es exitoso retorna verdadero
     */
    public static function createArea($hectarea, $metros, $area_cons, $predio, $anno){
        try {
            $data = DB::table('gr_area')
                        ->insert([
                            "valor"            => empty($hectarea)?0:$hectarea,
                            "area_metros"      => empty($metros)?0:$metros,
                            "area_construida"  => empty($area_cons)?0:$area_cons,
                            "predio"           => $predio,
                            "anio"             => $anno,
                            "tipoarea"         => 1,
                            "unidadarea"       => 1,
                            "motivocambioarea" => 3
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpAva
     * Metodo para buscar el avaluo respecto a un predio y una vigencia especifica
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param String $anio Año
     * @return Collection $data Datos obtenidos de la bd
     */
    public static function lookUpAva($predio, $anio){
        try {
            $data = DB::table('gr_avaluo')
                        ->where('predio', '=', $predio)
                        ->where('anno', '=', $anio)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * UpdateAva
     * Metodo para actualizar datos en la base de datos
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id Id del avaluo
     * @param double $valor Valor a actualizar
     * @return bool $data Cuando actualizar retorna verdadero
     */
    public static function UpdateAva($id, $valor){
        try {
            $data = DB::table('gr_avaluo')
                        ->where('id_unico', '=', $id)
                        ->update(['valor' => $valor]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updateTarAva
     * Función para actualizar la tarifa
     * @param int $id Id de predio
     * @param int $valor Id de tarifa
     * @param String $anno Valor de año
     * @return bool $data Si los datos son actualizados retornaverdadero
     */
    public static function updateTarAva($id, $valor, $anno){
        try {
            $data = DB::table('gr_avaluo')
                        ->where('predio', '=', $id)
                        ->where('anno', '=', $anno)
                        ->update(['tarifa' => $valor]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * UpdateState
     * Metodo para actualizar estado del predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param int $estado Id del estado
     * @return bool $data Retorna verdadero si el estado del predio es actualizado
     */
    public static function UpdateState($predio, $estado){
        try {
            $data = DB::table('gp_predio1')
                        ->where('id_unico', '=', $predio)
                        ->update([
                            "estado" => $estado
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * createAva
     * Metodo para crear o reregistrar avaluo
     * @author Alexander Numpaque
     * @package Predial
     * @param int|ddouble $valor Valor a registrar
     * @param int $indicador Indicador 1 ó 0
     * @param int $tarfia Id de tarifa
     * @param int $predio Id de predio
     * @param String $anno Año del predio
     * @return Collection $data Retorna verdadero si los datos son registrados en la bd
     */
    public static function createAva($valor, $indicador, $tarfia, $predio, $anno){
        try {
            $data = DB::table('gr_avaluo')
                        ->insert([
                            "valor"     => $valor,
                            "indicador" => 1,
                            "tarifa"    => $tarfia,
                            "predio"    => $predio,
                            "anno"      => $anno
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * savePr
     * Metodo para guardar predio
     * @author Alexander Numpaque
     * @package Predial
     * @param String $codC Codigo Catastral
     * @param String $dir Dirección del predio
     * @param int $tipo Tipo de predio
     * @param String $nom Nombre del predio
     * @param String $anioC Año de creación
     * @param int $est Estado de predio
     * @param int $esato Estrato de predio
     * @param int $predA Predio Asociado
     * @param int $des Destino Economico
     * @param String $aniI Inicio de vigencia
     * @param String $codA Codigo Catastral
     * @return bool $data Si es insertado en la base de datos retorna verdadero
     */
    public static function savePr($codC, $dir, $tipo, $nom, $anioC, $est, $esato, $predA, $des, $aniI, $codA){
        try {
            $data = DB::table('gp_predio1')
                        ->insert([
                            "codigo_catastral"          => $codC,
                            "codigo_catastral_anterior" => $codA,
                            "direccion"                 => $dir,
                            "tipo_predio"               => $tipo,
                            "nombre"                    => $nom,
                            "aniocreacion"              => $anioC,
                            "estado"                    => $est,
                            "estrato"                   => $esato,
                            "predioAso"                 => $predA,
                            "destino_economico"         => $des,
                            "inicio_vigencia"           => $aniI
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * validateNumDoc
     * Metodo para agregar ceros restantes al numero de documento
     * @author Alexander Numpaque
     * @package Predial
     * @param String $numdoc Numero de documento
     * @return String Numero de documento
     */
    public static function validateZeroNumDoc($numdoc){
        return str_pad($numdoc, 12, '0', STR_PAD_LEFT);
    }

    /**
     * validateIsProp
     * Metodo para validar si el propietario tiene orden 001
     * @author Alexander Numpaque
     * @package Predial
     * @param String $ord Orden del propietario;
     * @return int $xipro Retorna 0 cuando el orden es 001 sino es 1
     */
    public static function validateIsProp($ord){
        if($ord == "001"){
            $xipro = 0;
        }else{
            $xipro = 1;
        }
        return $xipro;
    }

    /**
     * getLastProp
     * Metodo para obtener el ultimo propietario registrado respecto a un numero de identificacion
     * @author Alexander Numpaque
     * @package Predial
     * @param String $numero Número de identificación
     * @return Collection $data Datos obtenidos por la consulta
     */
    public static function getLastProp($numero){
        try {
            $data = DB::table('gr_propietarios')
                        ->where('numero', '=', $numero)
                        ->max('id_unico');
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updateDir
     * Metodo para actualizar la dirección del propietario
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id Id del propietario
     * @param String $direccion Dirección del predio
     * @return Bool $data Retorna verdadero si es actualizado
     */
    public static function updateDir($id, $direccion){
        try {
            $data = DB::table('gr_propietarios')
                        ->where('id_unico', '=', $id)
                        ->update([
                            "direccion" => $direccion
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpMaxAva
     * Metodo para buscar el último registro de avaluo por predio y vigencia
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param String $vig Vigencia del predio
     * @return Collection $data Valores obtenidos de base de datos
     */
    public static function lookUpMaxAva($predio, $vig){
        try {
            $data = DB::table('gr_avaluo')
                        ->where('predio', '=', $predio)
                        ->where('anno', '=', $vig)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updateA
     * Función para actualizar la tarifa del ara
     * @author Alexander Numpaque
     * @package Predial
     * @param int $id Id de area
     * @param int $tarifa Id de tarifa
     * @return bool $data Retorna 1 o verdadero si se actualizo los valores en la base de datos
     */
    public static function updateA($id, $tarifa){
        try {
            $data = DB::table('gr_avaluo')
                        ->where('id_unico', '=', $id_unico)
                        ->update([
                            "tarifa" => $tarifa
                        ]);
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * getTarAvaV
     * Función para obtener la tarifa de un predio respecto a un avaluo
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param String $vig String o vigencia
     * @return Collection $data Datos obtenidos por base de datos
     */
    public static function getTarAvaV($predio, $vig){
        try {
            $data = DB::table('gr_avaluo')
                        ->select('tarifa')
                        ->where('predio', '=', $predio)
                        ->where('anno', '=', $vig)
                        ->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * getLastResPre
     * Función para obtener el ultimo registro de resolución predio
     * @author Alexander Numpaque
     * @package Predial
     * @param int $predio Id del predio
     * @param date $fecha Fecha de la resolución
     * @param int $resolucion Id de resolución
     * @return int $data Id de resolucion predio
     */
    public static function getLastResPre($predio, $resolucion){
        try {
            $data = DB::table('gr_resolucion_predio')
                        ->where('predio', '=', $predio)
                        ->where('resolucion', '=', $resolucion)
                        ->max('id_unico');
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updatePre
     * Actualizar predio
     * @author Alexander Numpaquer
     * @package Predial
     * @param int $predio Id del predio
     * @param int $tipo Id de tipo
     * @param int $estrato Id de estrato
     * @param String $nombre Nombre del predio
     * @return bool $data Retorna verdadero si los datos son actualizados
     */
    public static function updatePre($predio, $tipo, $estrato){
        try {
            $data = DB::table('gp_predio1')
                        ->where('id_unico', '=', $predio)
                        ->update([
                            "tipo_predio" => $tipo,
                            "estrato"     => $estrato
                        ]);
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * getLastPredio
     * Función para obtener el último predio registrado
     * @author Alexander Numpaquer
     * @package Predial
     * @return int $data Id del ultimo predio registrado
     */
    public static function getLastPredio(){
        try {
            $data = DB::table('gp_predio1')->max('id_unico');
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * lookUpPreId
     * @author Alexander Numpaquer
     * @package Predial
     * @param int $id Id del predio
     * @return Array|Collection $data Datos del predio
     */
    public static function lookUpPreId($id){
        try {
            $data = DB::table('gp_predio1')->where('id_unico', '=', $id)->first();
            return $data;
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * updatePrND
     * Función para actualizar dirección y nombre del predio
     * @param int $id Id del predio
     * @param String $direccion Dirección
     * @param String $nombre Nombre del predio
     * @return bool $data Retorna verdadero cuando se modifica el predio
     */
    public static function updatePrND($id, $direccion, $nombre){
        try {
            $data = DB::table('gp_predio1')
                        ->where('id_unico', '=', $id)
                        ->update([
                            "direccion" => $direccion,
                            "nombre"    => $nombre
                        ]);
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    public static function validarExistePropietarioOrden($tercero, $predio, $orden){
        try {
            $data = DB::table('gp_tercero_predio')
                        ->where('tercero', '=', $tercero)
                        ->where('predio', '=', $predio)
                        ->where('orden', '=', $orden)
                        ->first();
        } catch (Exception $e) {
            return $e->getMessage();
        }
    }

    /**
     * storeInfo
     * Metodo de procesamiento y guardado de los detalles de resolución
     * @author Alexander Numpaque
     * @package Predial
     * @param Request $request Receptor del formulario
     * @return flash flash Clase para enviar mensajes entre pantallas
     */
    public static function storeInfo(Request $request){
        list($str, $predio, $vig) = array("", "", "");
        $id     = decrypt($request->txtResolucion); #Id de Resolución
        $data   = ResolucionController::lookUpResId($id);
        $dres   = Resolucion::find($id);#Buscamos los datos de la resolución
        $fecha  = $dres->fecha;
        foreach ($data as $value){
            $vig    = $value->anno;
            if(!empty($value->codigo_catastral)){
                $predio = ResolucionController::lookUpPC($value->codigo_catastral);
                //$svmut  = ResolucionController::saveMutation($fecha, $id, $predio->id_unico);#Guardamos la mutación courrida en el predio
            }
            if(!empty($predio->id_unico)){#Validamos que el predio esta registrado
                $dtresp = ResolucionController::getLastResPre($predio->id_unico, $fecha, $id);#Obtnemos el id de la mutación
                if(!empty($value->numerodoc)){#Validamos que exista un número de documento
                    $numdoc = ResolucionController::validateZeroNumDoc($value->numerodoc);
                    $tpr    = ResolucionController::lookUpTerp($predio->id_unico);
                    if(count($tpr) > 0){#Validamos que exista propietario relacionado al predio
                        $ter   = ResolucionController::lookUpPro($numdoc, $value->direccion);
                        if(empty($ter)){
                            $tpdoc = ResolucionController::validateTypeDoc($value->tipodocumento);
                            $save  = ResolucionController::saveDataProp($value->nombre_propietario, $tpdoc, $numdoc, $value->direccion);
                            $ter   = ResolucionController::lookUpPro($numdoc, $value->direccion);
                            if(!empty($dtresp)){
                                $sctnm = ResolucionController::saveDetailMutation("NULL", $value->nombre_propietario, $dtresp, 3, 1);
                                $sctrp = ResolucionController::saveDetailMutation("NULL", $tpdoc, $dtresp, 3, 1);
                                $sctnd = ResolucionController::saveDetailMutation("NULL", $numdoc, $dtresp, 3, 1);
                                $sctdr = ResolucionController::saveDetailMutation("NULL", $value->direccion, $dtresp, 3, 1);
                            }
                            $ter   = ResolucionController::lookUpPro($numdoc, $value->direccion);
                        }
                        $xor   = ResolucionController::lookUpTerOr($predio->id_unico, $value->orden_propietario);
                        if(!empty($xor)){
                            $dlr   = ResolucionController::deleteTerOr($predio->id_unico, $xor->tercero);
                        }
                        $xipro = ResolucionController::validateIsProp($value->orden_propietario);
                        $inr   = ResolucionController::saveProP($predio->id_unico, $ter->id_unico, $xipro, $value->orden_propietario, 0);
                    }elseif(count($tpr) == 0){#Si no tiene predio relacioando
                        $ter   = ResolucionController::lookUpPro($numdoc, $value->direccion);
                        if(empty($ter)){
                            $tpdoc = ResolucionController::validateTypeDoc($value->tipodocumento);
                            $save  = ResolucionController::saveDataProp($value->nombre_propietario, $tpdoc, $numdoc, $value->direccion);
                            if(!empty($dtresp)){
                                $sctnm = ResolucionController::saveDetailMutation("NULL", $value->nombre_propietario, $dtresp, 3, 1);
                                $sctrp = ResolucionController::saveDetailMutation("NULL", $tpdoc, $dtresp, 3, 1);
                                $sctnd = ResolucionController::saveDetailMutation("NULL", $numdoc, $dtresp, 3, 1);
                                $sctdr = ResolucionController::saveDetailMutation("NULL", $value->direccion, $dtresp, 3, 1);
                            }
                            $ter   = ResolucionController::lookUpPro($numdoc, $value->direccion);
                        }
                        $xor   = ResolucionController::lookUpTerOr($predio->id_unico, $value->orden_propietario);
                        $xexr  = ResolucionController::validarExistePropietarioOrden($ter->id_unico, $predio->id_unico, $value->orden_propietario);

                        if(!empty($xor)){
                            $dlr   = ResolucionController::deleteTerOr($predio->id_unico, $xor->tercero);
                        }

                        if(!empty($xexr)){
                            $xipro = ResolucionController::validateIsProp($value->orden_propietario);
                            $inr   = ResolucionController::saveProP($predio->id_unico, $ter->id_unico, $xipro, $value->orden_propietario, 0);
                        }
                    }
                    // Posible fallo en cambio de estado de cancelación, rediseño de metodo
                    if($value->estado == "C"){
                        $xest = ResolucionController::UpdateState($predio->id_unico, 3);
                    }
                    // Cambio de estado si el predio tiene estado cancelado
                    if($predio->estado == 3 AND $value->estado == "I"){
                        $xest = ResolucionController::UpdateState($predio->id_unico, 2);
                    }
                }
                if(!empty($vig)){
                    $area = ResolucionController::lookUpA($predio->id_unico, $vig);
                    $dtresp = ResolucionController::getLastResPre($predio->id_unico, $id);#Obtnemos el id de la mutación
                    if($value->hectarea == 0 && $value->metros_c == 0 && $value->area_cons == 0){}else{
                        if(!empty($area->id_unico)){
                            $dlA  = ResolucionController::deleteArea($area->id_unico);
                        }
                        $updA = ResolucionController::updateArea(empty($value->hectarea)?0:$value->hectarea, empty($value->metros_c)?0:$value->metros_c, empty($value->area_cons)?0:$value->area_cons, $predio->id_unico, $vig);
                        if(!empty($dtresp)){
                            $scthc = ResolucionController::saveDetailMutation("NULL", $value->hectarea, $dtresp, 3, 2);
                            $sctmc = ResolucionController::saveDetailMutation("NULL", $value->metros_c, $dtresp, 3, 2);
                            $sctac = ResolucionController::saveDetailMutation("NULL", $value->area_cons, $dtresp, 3, 2);
                        }
                    }
                    if(!empty($value->avaluo)){
                        $xavv = ResolucionController::lookUpAva($predio->id_unico, $vig);
                        $dtresp = ResolucionController::getLastResPre($predio->id_unico, $id);#Obtnemos el id de la mutación
                        if(!empty($xavv)){
                            $uavv = ResolucionController::UpdateAva($xavv->id_unico, $value->avaluo);
                            if(!empty($dtresp)){
                                $scav = ResolucionController::saveDetailMutation("NULL", $value->avaluo, $dtresp, 3, 4);
                            }
                        }
                    }
                }

                if(!empty($value->des)){
                    $xDes = ResolucionController::lookUpD($value->des);
                    if(!empty($xDes->id_unico)){
                        ResolucionController::updateD($predio->id_unico, $xDes->id_unico);
                    }
                }
            }else{
                list($lstprp, $idPredio) = array("", "");
                if(!empty($value->codigo_catastral)){
                    $savPre   = ResolucionController::savePr($value->codigo_catastral, NULL, NULL, NULL, date("Y"), 2, NULL, NULL, NULL, date("Y"), NULL);
                    $idPredio = ResolucionController::lookUpPC($value->codigo_catastral);
                    $svmut    = ResolucionController::saveMutation($fecha, $id, $idPredio->id_unico);#Guardamos la mutación courrida en el predio
                    $dtresp = ResolucionController::getLastResPre($idPredio->id_unico, $id);#Obtnemos el id de la mutación
                    if(!empty($dtresp)){
                        $cretpc = ResolucionController::saveDetailMutation("NULL", $value->codigo_catastral, $dtresp, 3, 5);
                    }
                }

                if(!empty($value->numerodoc)){
                    $numdoc = ResolucionController::validateZeroNumDoc($value->numerodoc);
                    $xipro  = ResolucionController::validateIsProp($value->orden_propietario);
                    $tpdoc  = ResolucionController::validateTypeDoc($value->tipodocumento);
                    $dxprop = ResolucionController::saveDataProp($value->nombre_propietario, $tpdoc, str_pad($value->numerodoc, 12, '0', STR_PAD_LEFT), "NULL");
                    $dtresp = ResolucionController::getLastResPre($idPredio->id_unico, $id);#Obtnemos el id de la mutación
                    if(!empty($dtresp)){
                        $crepro = ResolucionController::saveDetailMutation("NULL", $value->nombre_propietario, $dtresp, 3, 5);
                        $cretpc = ResolucionController::saveDetailMutation("NULL", $tpdoc, $dtresp, 3, 5);
                        $crenum = ResolucionController::saveDetailMutation("NULL", $numdoc, $dtresp, 3, 5);
                    }
                    $lstprp = ResolucionController::getLastProp($numdoc);
                    $savedp = ResolucionController::saveProP($idPredio->id_unico, $lstprp, $xipro, $value->orden_propietario, 0);
                    if(!empty($value->direccion)){
                        $updprp = ResolucionController::updateDir($lstprp, $value->direccion);
                        $upddir = ResolucionController::updateDir($idPredio->id_unico, $value->direccion);
                        if(!empty($dtresp)){
                            $credir = ResolucionController::saveDetailMutation("NULL", $value->direccion, $dtresp, 3, 5);
                        }
                    }
                    $creare = ResolucionController::createArea($value->hectarea, $value->metros_c, $value->area_cons, $idPredio->id_unico, $vig);
                    if(!empty($dtresp)){
                        $crehec = ResolucionController::saveDetailMutation("NULL", $value->hectarea, $dtresp, 3, 5);
                        $cremec = ResolucionController::saveDetailMutation("NULL", $value->metros_c, $dtresp, 3, 5);
                        $creacn = ResolucionController::saveDetailMutation("NULL", $value->area_cons, $dtresp, 3, 5);
                    }
                }
                if(!empty($value->vigencia) AND !empty($value->avaluo)){
                    $lasP     = ResolucionController::getLastPredio();
                    $idPredio = ResolucionController::lookUpPreId($lasP);
                    $dtresp   = ResolucionController::getLastResPre($idPredio->id_unico, $id);#Obtnemos el id de la mutación
                    $creta    = ResolucionController::createAva($value->avaluo, 1, NULL, $idPredio->id_unico, $vig);
                    if(!empty($dtresp)){
                        $creav    = ResolucionController::saveDetailMutation("NULL", $value->avaluo, $dtresp, 3, 5);
                    }
                }
                if(!empty($value->des)){
                    $lasP     = ResolucionController::getLastPredio();
                    $idPredio = ResolucionController::lookUpPreId($lasP);
                    $dtresp   = ResolucionController::getLastResPre($idPredio->id_unico, $id);#Obtnemos el id de la mutación
                    $idDes    = ResolucionController::lookUpD($value->des);
                    $updDe    = ResolucionController::updateD($idPredio->id_unico, $idDes->id_unico);
                    if(!empty($dtresp)){
                        $creav    = ResolucionController::saveDetailMutation("NULL", $value->des, $dtresp, 3, 5);
                    }
                }
                if(!empty($value->cod_padre)){
                    $lasP     = ResolucionController::getLastPredio();
                    $idPredio = ResolucionController::lookUpPreId($lasP);
                    $dtresp   = ResolucionController::getLastResPre($idPredio->id_unico, $id);#Obtnemos el id de la mutación
                    $dtp      = ResolucionController::lookUpPC($value->cod_padre);
                    if($vig >= date("Y")){
                        $updt     = ResolucionController::getTarAvaV($dtp->id_unico, $vig);
                        $xavat    = ResolucionController::lookUpMaxAva($idPredio->id_unico, $vig);
                        $uptava   = ResolucionController::updateTarAva($idPredio->id_unico, $updt->tarifa, $vig);
                    }
                    $updPrd   = ResolucionController::updatePre($idPredio->id_unico, $dtp->tipo_predio, $dtp->estrato);
                    if(!empty($dtresp)){
                        $cretpp   = ResolucionController::saveDetailMutation("NULL", $dtp->tipo_predio, $dtresp, 3, 5);
                        $creest   = ResolucionController::saveDetailMutation("NULL", $dtp->estrato, $dtresp, 3, 5);
                        $cretar   = ResolucionController::saveDetailMutation("NULL", $updt->tarifa, $dtresp, 3, 5);
                    }
                }
                if(!empty($value->direccion)){
                    $lasP     = ResolucionController::getLastPredio();
                    $idPredio = ResolucionController::lookUpPreId($lasP);
                    $dtresp   = ResolucionController::getLastResPre($idPredio->id_unico, $id);#Obtnemos el id de la mutación
                    $updDP    = ResolucionController::updatePrND($idPredio->id_unico, $value->direccion, $value->direccion);
                }
            }
        }
        flash()->overlay('Información registrada correctamente.','Información');
        return back();
    }

    public function validarEstado($x){
        switch ($x){
            case 'I':
                $estado = 2;
                break;
            case 'F':
                $estado = 1;
                break;
            case 'C';
                $estado = 3;
                break;
        }
        return $estado;
    }

    public function VistaArchivo(){
        return view($this->path.'.excel');
    }

    public function leerArchivo(Request $request){
        ini_set('max_execution_time', 0);
        if($request->hasFile('txtArchivo')){
            $ruta  = $request->file('txtArchivo')->getRealPath();
            $dataX = Excel::load($ruta)->get();
            //var_dump($ruta);
            if($dataX->count()){
                foreach ($dataX as $key => $row){
              //      var_dump($row['estado_predio']);
                    $estadoPredio      = $row['estado_predio'];
                    $codigoCatastral   = $row['codigo_catastral'];
                    $npm               = $row['npm'];
                    $nombrePropietario = $row['nombre_propietario'];
                    $tipoDocumento     = $row['tipo_documento'];
                    $numeroDocumento   = $row['numero_documento'];
                    $ordenPropietario  = $row['orden_propietario'];
                    $direccion         = $row['direccion'];
                    $destinoEconomico  = $row['destino_economico'];
                    $hectarea          = $row['hectarea'];
                    $metrosConstruidos = $row['metros_construidos'];
                    $areaConstruida    = $row['area_construida'];
                    $avaluo            = $row['avaluo'];
                    $vigencia          = $row['vigencia'];
                    $fecha             = $row['fecha'];
                    $codigoPadre       = $row['codigo_padre'];
                    
                    $data    = Predio::where('codigo_catastral', $codigoCatastral)->first();/*Buscamos que el predio exista*/
                    $estado  = $this->validarEstado($estadoPredio);/*Validamos el estado del predio para obtener el id*/
                    $numero  = $this->validateZeroNumDoc($numeroDocumento);/*Validamos el numero de documento del propietario*/
                    $tipo    = $this->validateTypeDoc($tipoDocumento);/*Validamos el tipo de documento*/
                    $destino = $this->lookUpD($destinoEconomico);
                    if(count($data) > 0){/*Validamos que exista el predio*/
                        $predio = Predio::find($data->id_unico);/*Modificamos los datos del predio*/
                        $predio->estado            = $estado;
                        $predio->direccion         = $direccion;
                        $predio->nombre            = $direccion;
                        $predio->destino_economico = $destino->id_unico;
                        $predio->save();

                        if($estadoPredio == "C"){/*Si el estado es cancelado eliminados la relación de propietario predio*/
                            $prop = Propietario::where('numero', $numero)->where('direccion', $direccion)->first();
                            if(count($prop) > 0){
                                DB::table('gp_tercero_predio')->where('tercero', $prop->id_unico)->where('predio', $data->id_unico)->delete();
                            }
                            $xAv  = Avaluo::where('predio', $data->id_unico)->where('anno', $vigencia)->first();
                            if(count($xAv)>0){
                                if($xAv->valor != $avaluo){
                                    if(!empty($xAv->id_unico)){
                                        $xCar = DB::table('gr_cartera_obligada')->where('avaluo', $xAv->id_unico)->where('predio', $data->id_unico)->first();
                                        if(count($xCar) == 0){ 
                                            $xAAA = DB::table('gr_detalle_factura_predial')->where('avaluo', $xAv->id_unico)->first();
                                            if(count($xAAA) == 0){ 
                                                Avaluo::where('predio', $data->id_unico)->where('anno', $vigencia)->delete();
                                            }
                                        }
                                    }
                                }
                            }
                        }else{
                            /*De lo contrario Creamos el propietario*/
                            $prop                     = new Propietario();
                            $prop->nombres            = $nombrePropietario;
                            $prop->tipoidentificacion = $tipo;
                            $prop->numero             = $numero;
                            $prop->dcasadaVida        = 0;
                            $prop->direccion          = $direccion;
                            $prop->save();

                            $xprop = $this->lookUpPro($numero, $direccion);
                            if(count($xprop) > 0){/*Relacionamos predio y propietario*/
                                $xxx = PropietarioPredio::where('predio', $data->id_unico)->where('tercero', $xprop->id_unico)->first();
                                if(empty($xxx)){
                                    $xes              = $this->validateIsProp($ordenPropietario);
                                    $xpr              = new PropietarioPredio();
                                    $xpr->tercero     = $xprop->id_unico;
                                    $xpr->predio      = $data->id_unico;
                                    $xpr->propietario = $xes;
                                    $xpr->orden       = $ordenPropietario;
                                    $xpr->porcentaje  = 0;
                                    $xpr->save();
                                }
                            }
                        }

                        $xpa = $this->lookUpAva($data->id_unico, $vigencia);/*Buscamos el avaluo para la vigencia a registrar*/
                        if(count($xpa) > 0){/*Si avaluo existe para la vigencia, lo modificamos*/
                            $xvalor_a = Avaluo::where('predio', $data->id_unico)->where('anno', $vigencia)->first();
                            $xavaluo  = Avaluo::find($xpa->id_unico);
                            $xavaluo->valor = $avaluo;
                            $xavaluo->save();
                        }else{
                            //Buscamos si hay una tarifa ára elñ anio , el destino y el valor 
                            $xtar1 = DB::table('gr_tarifa as t')
                             ->where('t.destino_economico', $destino->id_unico)
                             ->where('t.anio', $vigencia)
                            ->whereRaw('? BETWEEN t.limiteinferior AND t.limitesuperior', [$avaluo])
                             ->first();
                            if(count($xtar1)>0){
                                $xavaluo            = new Avaluo();
                                $xavaluo->valor     = $avaluo;
                                $xavaluo->indicador = 0;
                                $xavaluo->tarifa    = $xtar1->id_unico;
                                $xavaluo->predio    = $data->id_unico;
                                $xavaluo->anno      = $vigencia;
                                $xavaluo->save();
                            } else {
                                $xan = $this->lookUpAva($data->id_unico, ($vigencia - 1));
                                if(count($xan) > 0){/*Guardamos el avaluo y buscamos la tarifa en la vigencia actual con el codigo de la vigencia anterior*/
                                    $xtrx = DB::table('gr_tarifa')->where('id_unico', $xan->tarifa)->first();
                                    $xtar = DB::table('gr_tarifa')->where('codigotarifa', $xtrx->codigotarifa)->where('anio', $vigencia)->first();
                                    if(count($xtar) > 0){
                                        $xavaluo            = new Avaluo();
                                        $xavaluo->valor     = $avaluo;
                                        $xavaluo->indicador = 0;
                                        $xavaluo->tarifa    = $xtar->id_unico;
                                        $xavaluo->predio    = $data->id_unico;
                                        $xavaluo->anno      = $vigencia;
                                        $xavaluo->save();
                                    }
                                }
                            }                            
                        }

                        $xar = $this->lookUpA($data->id_unico, $vigencia);/*Buscamos el area para la vigencia a registrar*/
                        if(count($xar) > 0){
                            $area                  = Area::find($xar->id_unico);/*Modificamos el area existente con los nuevos datos*/
                            $area->valor           = $hectarea;
                            $area->area_construida = $areaConstruida;
                            $area->area_metros     = $metrosConstruidos;
                            $area->save();
                        }else{
                            $area                   = new Area();/*Creamos un nuevo area*/
                            $area->valor            = $hectarea;
                            $area->anio             = $vigencia;
                            $area->tipoarea         = 1;
                            $area->unidadarea       = 1;
                            $area->motivocambioarea = 3;
                            $area->predio           = $data->id_unico;
                            $area->area_construida  = $areaConstruida;
                            $area->area_metros      = $metrosConstruidos;
                            $area->save();
                        }

                        if(!empty($codigoPadre)){
                            $xant  = $this->lookUpAva($data->id_unico, ($vigencia));
                            /*if(count($xant) == 0){
                                $padre = Predio::where('codigo_catastral', $codigoPadre)->first();
                                $xan   = $this->lookUpAva($padre->id_unico, $vigencia);
                                if(count($xan) > 0){
                                    $xtrx  = DB::table('gr_tarifa')->where('id_unico', $xan->tarifa)->first();
                                    $xtar  = DB::table('gr_tarifa')->where('codigotarifa', $xtrx->codigotarifa)->where('anio', $vigencia)->first();
                                    $xavaluo            = new Avaluo();
                                    $xavaluo->valor     = $avaluo;
                                    $xavaluo->indicador = 0;
                                    $xavaluo->tarifa    = $xtar->id_unico;
                                    $xavaluo->predio    = $data->id_unico;
                                    $xavaluo->anno      = $vigencia;
                                    $xavaluo->save();
                                }
                            }*/
                        }
                    }else{
                        /*Registramos los datos del predio*/
                        $padre                             = Predio::where('codigo_catastral', $codigoPadre)->first();
                        $predio                            = new Predio();
                        $predio->codigo_catastral          = $codigoCatastral;
                        $predio->codigo_catastral_anterior = ($codigoCatastral != $codigoPadre)?$codigoPadre:'NULL';
                        $predio->matricula_inmobiliaria    = 'NULL';
                        $predio->direccion                 = $direccion;
                        $predio->codigo_sig                = 'NULL';
                        $predio->ciudad                    = NULL;
                        $predio->barrio                    = NULL;
                        $predio->ruta                      = NULL;
                        $predio->tipo_predio               = $padre->tipo_predio;
                        $predio->nombre                    = $direccion;
                        $predio->aniocreacion             = date("Y");
                        $predio->codigoigac                = 'NULL';
                        $predio->estado                    = 2;
                        $predio->estrato                   = $padre->estrato;
                        $predio->predioaso                 = $padre->id_unico;
                        $predio->destino_economico         = $destino->id_unico;
                        $predio->inicio_vigencia           = date("Y");
                        $predio->save();

                        $xpredio = Predio::where('codigo_catastral', $codigoCatastral)->first();/*Buscamos que el predio exista*/
                        /*Creamos el predio*/
                        $prop                     = new Propietario();
                        $prop->nombres            = $nombrePropietario;
                        $prop->tipoidentificacion = $tipo;
                        $prop->numero             = $numero;
                        $prop->dcasadaVida        = 0;
                        $prop->direccion          = $direccion;
                        $prop->save();

                        $xprop = $this->lookUpPro($numero, $direccion);
                        if(count($xprop) > 0){/*Relacionamos predio y propietario*/
                            $xxx = PropietarioPredio::where('predio', $xpredio->id_unico)->where('tercero', $xprop->id_unico)->first();
                            if(empty($xxx)){
                                $xes              = $this->validateIsProp($ordenPropietario);
                                $xpr              = new PropietarioPredio();
                                $xpr->tercero     = $xprop->id_unico;
                                $xpr->predio      = $xpredio->id_unico;
                                $xpr->propietario = $xes;
                                $xpr->orden       = $ordenPropietario;
                                $xpr->porcentaje  = 0;
                                $xpr->save();
                            }
                        }
                        //Buscamos si hay una tarifa ára elñ anio , el destino y el valor 
                        $xtar1 = DB::table('gr_tarifa as t')
                         ->where('t.destino_economico', $destino->id_unico)
                         ->where('t.anio', $vigencia)
                         ->whereBetween('t.limiteinferior', [0, $avaluo])
                         ->AndwhereBetween($avaluo, ['t.limiteinferior', 't.limitesuperior'])
                         ->first();
                        if(count($xtar1)>0){
                            $xavaluo            = new Avaluo();
                            $xavaluo->valor     = $avaluo;
                            $xavaluo->indicador = 0;
                            $xavaluo->tarifa    = $xtar1->id_unico;
                            $xavaluo->predio    = $xpredio->id_unico;
                            $xavaluo->anno      = $vigencia;
                            $xavaluo->save();
                        } else {
                            $xan  = $this->lookUpAva($padre->id_unico, $vigencia);
                            $xtrx = DB::table('gr_tarifa')->where('id_unico', $xan->tarifa)->first();
                            $xtar = DB::table('gr_tarifa')->where('codigotarifa', $xtrx->codigotarifa)->where('anio', $vigencia)->first();
                            $xavaluo            = new Avaluo();
                            $xavaluo->valor     = $avaluo;
                            $xavaluo->indicador = 0;
                            $xavaluo->tarifa    = $xtar->id_unico;
                            $xavaluo->predio    = $xpredio->id_unico;
                            $xavaluo->anno      = $vigencia;
                            $xavaluo->save();
                        }

                        $area                   = new Area();/*Creamos un nuevo area*/
                        $area->valor            = $hectarea;
                        $area->anio             = $vigencia;
                        $area->tipoarea         = 1;
                        $area->unidadarea       = 1;
                        $area->motivocambioarea = 3;
                        $area->predio           = $xpredio->id_unico;
                        $area->area_construida  = $areaConstruida;
                        $area->area_metros      = $metrosConstruidos;
                        $area->save();
                    }
                }

                flash()->overlay('Información cargada correctamente.', 'Información');
                return back();
            }else{
                flash()->overlay('El archivo esta vacio.', 'Información');
                return back();
            }
        }
    }
}
