<?php namespace App\Http\Controllers;

use App\Custom\SQLConnection;
use App\Http\Controllers\MainController;
use App\Http\Controllers\AFIPController;
use App\Custom\Misc;
use Request;
use Session;
use stdClass;
use DateTime;
use DB;
class ApiControllerV2 extends Controller {


  public static function obtenerScoreView(){
    $cuit = '123123123';
    $apikey = '123123123';
    $razon_social = 'pepe';
    $download = false;
    $cliente = Session::get('usuario')->cliente['client_id'];
    $configuracion_personalizada = DB::table('score_personalizado')->where('client_id','=',$cliente)->get();
    $grupos = DB::table('score')->distinct()->select('nombre_grupo','id_grupo')->get();
    return View('Api/score')->with(compact('cuit','apikey','razon_social','download','configuracion_personalizada','grupos'));
  }

  public static function obtenerItems(){
    $id_grupo = request::input('id_grupo');
    $items = DB::table('score')->where('id_grupo','=',$id_grupo)->distinct()->select('item')->get();
    return json_encode($items);
  }

  public static function insertarScorePersonalizado(){
    $cliente      = Session::get('usuario')->cliente['client_id'];
    $valor        = !empty(request::input('valor')) ? request::input('valor') :0;
    $cant_desde   = !empty(request::input('cant_desde')) ? request::input('cant_desde') : NULL;
    $cant_hasta   = !empty(request::input('cant_hasta')) ? request::input('cant_hasta') :NULL;
    $dias_desde   = !empty(request::input('dias_desde')) ? request::input('dias_desde') :NULL;
    $dias_hasta   = !empty(request::input('dias_hasta')) ? request::input('dias_hasta') :NULL;
    $id_grupo     = request::input('id_grupo');
    $nombre_grupo = request::input('nombre_grupo');
    $item         = request::input('item');

    return SQLConnection::backendStoreProcedure('score_personalizado_insertar', array($cliente,$valor,$cant_desde,$cant_hasta,$dias_desde,$dias_hasta,$id_grupo,$nombre_grupo,$item),true);
  }


  /*
  Servicio de Score versión 2, armado en capas, con posibilidad de recibir parámetros del cliente.
  Recibe como parámetro el cuit, el cliente que lo consulta ( para poder sacar su configuración personalizada).
  Si el cliente no es enviado se toma la configuración Default
  */
  public static function obtenerScore($cuit='',$cliente=0){
    if(!$cuit){
      $cuit  = Request::input('cuit');
    }
    if($cliente == 0){
      $cliente = Request::input('cliente');
    }
    $usuario = Request::input('usuario');
    //arma una validación básica para la validación de un cuit
    $cuit_validado = Misc::validarCuit($cuit);
    if(!$cuit_validado){
      return json_encode(['killer'=>1,'evento'=>'Cuit Inválido','debug_score'=>'evento Killer de Cuit ( no cumple con los requisitos mínimos de un cuit válido)']);
    }
    //Si afip es true pasa por afip. 
    if(ENV('SERVICIOS_AFIP') == true){
      SQLConnection::busquedaPadron($cuit,1);
      AFIPController::obtenerPadron($cuit);
    }
    //obtener el tipo de persona consultada.
    $fisica_juridica = Misc::tipoPersona($cuit); 
    $p_fisica = ($fisica_juridica == 'F') ? true : false;

    
    /* Valido y proceso killers - inicio */
    
    $killers            = self::ProcesarKillersEnComun($cuit,$p_fisica);
    $killer = json_decode($killers)->killer;
    if($killer == 1){
      return $killers;
    }
    
    $killer_personalizado  = self::esKillerPersonalizado($cliente,$usuario)->personalizado;

    if($killer_personalizado > 0){
      $killers            = self::ProcesarKillersPersonalizados($cuit,$p_fisica,$cliente,$usuario);
      $killer = json_decode($killers)->killer;
      if($killer == 1){
        return $killers;
      }
    }
    /* Valido y proceso killers - fin */
  
  }

  //Función a reutilizar para configuración de Score, devuelve un bool para saber si se debe ir a consultar 
  public static function esKillerPersonalizado($cliente,$usuario){
    return SQLConnection::backendStoreProcedure('obtener_es_killer_personalizado', array($cliente,$usuario),true);
  }


  //Obtiene las fórmulas que tenga el cliente predefinidas para poder ver / modificar / borrar.
  public static function obtenerFormulas($cliente,$usuario){
    return SQLConnection::backendStoreProcedure('score_obtener_formulas', array($cliente,$usuario),true);
  }

  //Valida los killers en común en base a un cuit 
  public static function ProcesarKillersEnComun($cuit,$p_fisica){
     /* Si está fallecido o Sintomas de vitalidad = 0, el score da cero */
    $defuncion      = SQLConnection::obtenerDefuncion($cuit);
    if(isset($defuncion->fecha_deceso)){  
       return json_encode(['killer' =>1,'evento'=>'Deceso','debug_score'=>'Deceso']);
    }
    $killers = SQLConnection::backendStoreProcedure('score_obtener_killers_en_comun', array($cuit));

    if(!empty($killers)){
       return json_encode(['killer' =>1,'evento'=>'Juicios','debug_score'=>json_encode($killers)]);
    }
    if($p_fisica == false){
      $vitalidad =  SQLConnection::obtenerSintomasDeVitalidad($cuit);
      if(isset($vitalidad->vitalidad) && $vitalidad->vitalidad == 0){
        return json_encode(['killer' =>1,'evento'=>'Sintomas de Vitalidad','debug_score'=>'Sintomas de Vitalidad']);
      }
    }
    return json_encode(['killer' =>0,'evento'=>'','debug_score'=>'']);

  }
  //Valida los killers personalizados en base a un cuit, cliente
  public static function ProcesarKillersPersonalizados($cuit,$p_fisica,$cliente,$usuario){
    $killers    = SQLConnection::backendStoreProcedure('score_obtener_killers_personalizados', array($cuit,$cliente,$usuario));
    $contables  = SQLConnection::backendStoreProcedure('obtener_score_contable', array($cuit),'selectOne');

    if(!empty($killers)){
      foreach ($killers as $key => $value) {
       $cantidad    = false;
       $valor       = false;
       $antiguedad  = false;
       $situacion   = false;
       switch ($value->id_grupo) {
          case '1':
          /*  left join tipos_causas on
                  tipos_causas.id_tipo_causa = juicios.id_tipo_causa
        left join tiempo_causas on
                  tiempo_causas.cau_codigo   = juicios.id_tipo_causa
        left join padrones AS pf ON (pf.identificacion = cuit_actor) */
            $resp = DB::table('juicios')
            ->leftJoin('tipos_causas', 'tipos_causas.id_tipo_causa', '=', 'juicios.id_tipo_causa')
            ->leftJoin('tiempo_causas', 'tiempo_causas.cau_codigo', '=', 'juicios.id_tipo_causa')
            ->where('cuit_demandado','=',$cuit)
            ->where('visible','1');
            $items = $resp->get();
          break;

          //CHEQUES
          case '2':
            $resp = DB::table('chequesBCRA')->where('cuit_firmante','=',$cuit)->where('visible','1');
            if($value->valor > 0){
              $resp->where('importe','>=',$value->valor);
            } 
            if($value->dias_desde >= 0 and $value->dias_hasta > 0){
              $fecha_desde   = strtotime ( '-'.$value->dias_desde.' day' , strtotime ( date('Y-m-d') ) );
              $fecha_desde = date ( 'Y-m-d' , $fecha_desde );
              $fecha_hasta   = strtotime ( '-'.$value->dias_hasta.' day' , strtotime ( date('Y-m-d') ) );
              $fecha_hasta = date ( 'Y-m-d' , $fecha_hasta );
             
              $resp->where('fecha_rechazo','<=',$fecha_desde);
              $resp->where('fecha_rechazo','>',$fecha_hasta);
              if($value->codigo == 'CHEQUE_L'){
                $resp->whereNotNull('fecha_levantamiento');
              }else{
                $resp->whereNull('fecha_levantamiento');
              }
            }
            $items = $resp->get();
            $cantidad = sizeOf($items);
            if($value->cant_desde){
              if($cantidad >= (int)$value->cant_desde and $cantidad < (int)$value->cant_hasta ){
         //aaa       return json_encode(['killer' =>1,'evento'=>'Cheques','debug_score'=>json_encode($items)]); 
              }
            }
         break;

         //BANCOS
         case '3':
          $resp = DB::table('cendeu_temp')->where('iden','=',$cuit);
          if($value->codigo >= 2){
           $resp->where('situacion','>=',$value->codigo);
          }
          if($value->valor > 0){
            $resp->where('valor','>=',$value->valor);
          }
          if($value->dias_hasta > 0){
           $fecha_fuente = SQLConnection::backendStoreProcedure('obtener_fecha_fuente', array('cendeu'),true);
           $nuevafecha   = strtotime ( '-'.$value->dias_hasta.' day' , strtotime ( $fecha_fuente->fecha ) ) ;
           $fecha_maxima = date ( 'Ym' , $nuevafecha );
           $resp->where('fec_inf','>=',$fecha_maxima);
          }
          $items = $resp->get();
          $cantidad = sizeOf($items);
          if($value->cant_desde){
            if($cantidad >= (int)$value->cant_desde and ( (int)$value->cant_hasta  > 0 and $cantidad < (int)$value->cant_hasta)){
                return json_encode(['killer' =>1,'evento'=>'Central de Deudores','debug_score'=>json_encode($items)]); 
            }else if($cantidad >= (int)$value->cant_desde and ((int)$value->cant_hasta  == 0  or !$value->cant_hasta)) {
                return json_encode(['killer' =>1,'evento'=>'Central de Deudores','debug_score'=>json_encode($items)]); 
            }
          }
         if(!empty($items)){
      //aaa     return json_encode(['killer' =>1,'evento'=>'Central de Deudores','debug_score'=>json_encode($items)]);
         }

         break;
         //CONTABLES
         case '5':
         //30525346389

         $antiguedad_balance = date("Y-m-d", strtotime("-6 year"));
         $resp = DB::table('balances_contables')->where('cuit','=',$cuit)->where('visible','=',1)->where('estado','=','PUBLICADO')->where('fecha_balance','>=',$antiguedad_balance)->orderBy('fecha_balance', 'desc');
         $items = $resp->first();
         if(isset($items->{$value->item}) && ($items->{$value->item} >= $value->cant_desde && $items->{$value->item} < $value->cant_hasta )) {
           return json_encode(['killer' =>1,'evento'=>'Balances','debug_score'=>json_encode($items)]); 
         }
         break;
         default:
           # code...
           break;
       }
//        DB::select()
        # code...
      }
     //  return json_encode(['killer' =>1,'evento'=>'Juicios','debug_score'=>json_encode($killers)]);
    }

    return json_encode(['killer' =>0,'evento'=>'','debug_score'=>'']);

  }
  public static function ScoreSinKillers($cuit='',$secciones=array(),$cliente=0,$p_fisica){
    $debug_score = '';
    $calc_score['score']                      = $score;
    $calc_score['afecta_directo']             = [];
    $calc_score['afecta_directo']['total']    = 0;
    $calc_score['afecta_directo']['debug']    = '';
    $calc_score['afecta_indirecto']           = [];
    $calc_score['afecta_indirecto']['debug']  = '';
    $total_indirecto                          = [];
    
    $tabla_score    = SQLConnection::obtenerTablaScore();

    $tabla_score_ordenada     = [];
    
    foreach($tabla_score as $score){
      $score->cantidad = 0;
      $tabla_score_ordenada[$score->id_grupo][$score->codigo][] = $score;
    }
    $tabla_score_con_cantidades = $tabla_score_ordenada;
    $array_score_general    = SQLConnection::obtenerScore($cuit,$p_fisica);
    $score_fiscales         = SQLConnection::obtenerScoreFiscales($cuit,$p_fisica);

    $score = 70;
    foreach($array_score_general as $score_general){
        if($score_general->grupo ==2){
          $score_ordenado[$score_general->grupo][$score_general->codigo][$score_general->fecha][] = $score_general;
        }else{
          $score_ordenado[$score_general->grupo][$score_general->codigo][] = $score_general;
        }
    }
    $porcentaje_por_grupo       = SQLConnection::obtenerPorcentajePorGrupo($cuit);
    self::$porcentaje_por_grupo_afectado_por_preferencias = clone $porcentaje_por_grupo;
    $afectacion_score           = SQLConnection::obtenerPorcentajeScorePorAfectacion();

    $afectacion_score_ordenada  = [];
    foreach($afectacion_score as $key => $value){
      $afectacion_score_ordenada[$value->afecta_directo] = $value;
    }
    $link_pdf = env('HOST_NAS').'/'.substr($cuit, 0, 2).'/'.substr($cuit, 2, 3).'/'.substr($cuit, 5, 3).'/'.$cuit.'.pdf';
    self::$tiene_pdf = file_exists($link_pdf);
    if($p_fisica == true){
      //self::CalcularScorePersonaFisica($cuit,$secciones);
    }else{
    //  self::CalcularScorePersonaJuridica($cuit,$secciones);

    }
  }
  private static function CalcularScorePersonaFisica($cuit,$secciones){
    $porcentaje_cheques_no_propios            = 10;
    // Obtener Bancos para calcular si amerita por situación uno y sumar al score
    // Se almacenan en variable de clase para ser reutilizadas en la pestaña de bancos
    $obtener_bancos = SQLConnection::obtenerBancos($cuit);
    $situacion_1    = Misc::ameritaPorSituacionUno($obtener_bancos);
    self::$amerita_situacion_1 = $situacion_1['amerita'];
    self::$cantidad_situacion_1 = $situacion_1['cantidad'];
    if (self::$amerita_situacion_1) {
      $calc_score = Misc::sumaPorSituacionUno($calc_score, self::$cantidad_situacion_1);
    }
    if($demerita_por_edad){
      $calc_score = Misc::demeritarScorePorEdad($calc_score, self::$edad);
    }
    if($amerita_empleo){
      $calc_score = Misc::ameritaPorEmpleo($calc_score, self::$cuit);
    }
  }
  private static function CalcularScorePersonaJuridica($cuit,$secciones){

  }
}