<?php 

namespace App\Modules\AdegaVirada\Services;

use DB;
use App\Modules\Cadastro\Models\Cadastro;
use App\Modules\AdegaVirada\Models\AdegaVirada;
use App\Modules\AdegaViradaParticipantePedido\Models\AdegaViradaParticipantePedido;
use App\Modules\AdegaViradaParticipante\Models\AdegaViradaParticipante;
use App\Modules\AdegaViradaOferta\Models\AdegaViradaOferta;
use App\Modules\AdegaViradaResultado\Models\AdegaViradaResultado;
use App\Modules\AdegaViradaCupom\Models\AdegaViradaCupom;
use App\Modules\AdegaViradaCupomIndicacao\Models\AdegaViradaCupomIndicacao;
use App\Modules\AdegaViradaParticipanteIndicacao\Models\AdegaViradaParticipanteIndicacao;
use App\Services\GeralService;
use Illuminate\Support\Facades\Log;
use App\Modules\AdegaViradaCupom\Services\AdegaViradaCupomService;


class AdegaViradaService{

    public static function buscarAdegaVirada($anoEdicao = false, $force=FALSE){
        $dataAtual = date('Y-m-d H:i:s');
        if($force){
            return AdegaVirada::where('ano_edicao', $anoEdicao ? $anoEdicao : date('Y'))->first();
        }
        return AdegaVirada::where('ano_edicao', $anoEdicao ? $anoEdicao : date('Y'))->whereRaw("data_encerramento > '{$dataAtual}'")->first();
    }

    public static function buscarOfertas($anoEdicao, $offset = false, $limit = false){
        $adegaDaVirada = self::buscarAdegaVirada($anoEdicao, TRUE);
        
        $ofertas = AdegaViradaOferta::with(['produto.paisOrigem', 'oferta'])
        ->where('adega_virada_oferta.adega_virada_id', $adegaDaVirada->id);

        if($offset)
            $ofertas->skip($offset)->take($limit);
        if($limit)
            $ofertas->limit($limit);
        
        return $ofertas->groupBy('adega_virada_oferta.produto_id')
        ->orderBy('adega_virada_oferta.id', 'desc')
        ->get();
    }

    public static function incluirPedidoIndicacao($pedidoVenda, $adegaVirada){

        $cliente = $pedidoVenda->cliente;

        if(!$cliente->adegaViradaParticipante){
            $adegaViradaParticipanteId = DB::table('adega_virada_participante')->insertGetId([
                'adega_virada_id'             => $adegaVirada->id,
                'cadastro_id'                 => $cliente->id,
                'codigo'                      => GeralService::gerarCodigoAleatorio(),
                'data_cadastro'               => date('Y-m-d H:i:s'),
                'aceite_regulamento'          => 0,
                'data_aceite'                 => date('Y-m-d H:i:s'),
            ]);
        }else{
            $adegaViradaParticipanteId = $cliente->adegaViradaParticipante->id;
        }

        if(!$cliente->adegaViradaParticipanteIndicacao){
            Log::info('AdegaViradaService::incluirPedidoIndicacao ' . $pedidoVenda->id . ' => $cliente->adegaViradaParticipanteIndicacao is false');
            return false;
        }

        if(!empty($cliente->adegaViradaParticipanteIndicacao->adega_virada_cupom_id)){
            Log::info('AdegaViradaService::incluirPedidoIndicacao ' . $pedidoVenda->id . ' => $cliente->adegaViradaParticipanteIndicacao->adega_virada_cupom_id is not empty');
            return false;
        }

        if($pedidoVenda->subtotal < $adegaVirada->valor_pedidos_indicacao){
            Log::info('AdegaViradaService::incluirPedidoIndicacao ' . $pedidoVenda->id . ' => $pedidoVenda->subtotal < $adegaVirada->valor_pedidos_indicacao');
            return false;
        }

        $Indicacao = $pedidoVenda->adegaViradaParticipanteIndicacao;

        $participante = Cadastro::where('id', $Indicacao->participante->cadastro_id)->first();
        //Inclui Cupom para o Amigo que Indicou
        AdegaViradaService::incluirCupomCliente($participante, 'indicacao', $Indicacao);

        //Inclui Cupom para o Amigo Indicado
        $participante = Cadastro::where('id', $cliente->id)->first();
        AdegaViradaService::incluirCupomCliente($participante, 'indicacao');

        return true;

    }

    public static function incluirPedidoCliente($pedidoVenda, $adegaVirada){

        $cliente = $pedidoVenda->cliente;

        //1º step - seed adega_virada_participante
        if(!$cliente->adegaViradaParticipante){
            $adegaViradaParticipanteId = DB::table('adega_virada_participante')->insertGetId([
                'adega_virada_id'             => $adegaVirada->id,
                'cadastro_id'                 => $cliente->id,
                'valor_pedidos_proximo_cupom' => 0,
                'codigo'                      => GeralService::gerarCodigoAleatorio(),
                'data_cadastro'               => date('Y-m-d H:i:s')
            ]);
        }else{
            $adegaViradaParticipanteId = $cliente->adegaViradaParticipante->id;
        }

        $checkPedido = DB::table('adega_virada_participante_pedido')->where('adega_virada_participante_id', $adegaViradaParticipanteId)->where('pedido_venda_id', $pedidoVenda->id)->count();
        Log::info('AdegaViradaService::incluirPedidoCliente => checkPedido:' . $checkPedido);

        //2º step - seed adega_virada_participante_pedido
        if($checkPedido == 0){
            DB::table('adega_virada_participante_pedido')->insert([
                [
                    'adega_virada_participante_id' => $adegaViradaParticipanteId,
                    'pedido_venda_id'              => $pedidoVenda->id,
                    'total_pedido'                 => $pedidoVenda->total,
                    'situacao'                     => 'P',
                    'data_cadastro'                => date('Y-m-d H:i:s')
                ]
            ]);
        }

        //3º step - check adega_virada_cupom
        $totalParticipantePedido = AdegaViradaParticipantePedido::selectRaw('COALESCE(SUM(total_pedido),0) total_pedidos')
        ->join('adega_virada_participante', 'adega_virada_participante.id', '=', 'adega_virada_participante_pedido.adega_virada_participante_id')
        ->where('adega_virada_participante.cadastro_id', $cliente->id)
        ->whereRaw("adega_virada_participante_pedido.situacao = 'P' AND adega_virada_participante_pedido.adega_virada_cupom_id IS NULL")
        ->first();

        Log::info("AdegaViradaService::incluirPedidoCliente => total_pedidos: {$totalParticipantePedido->total_pedidos} - valor_pedidos_cupom: {$adegaVirada->valor_pedidos_cupom}");

        if($totalParticipantePedido->total_pedidos >= $adegaVirada->valor_pedidos_cupom){
            $cliente = Cadastro::where('id', $cliente->id)->first();
            AdegaViradaService::incluirCupomCliente($cliente);
        }else{
            DB::table('adega_virada_participante')->where('id', $adegaViradaParticipanteId)->update(['valor_pedidos_proximo_cupom' => $totalParticipantePedido->total_pedidos]);
        }

        return true;

    }

    /**
     * @param $cliente Object Model Cadastro
     * @param $tipo String 'pedido', 'indicacao'
     * @param $indicacao Object Model AdegaViradaParticipanteIndicacao
     */
    public static function incluirCupomCliente($cliente, $tipo='pedido', $indicacao = FALSE){

        $adegaViradaCupom = AdegaViradaCupomService::gerarNumeroCupom($cliente, $tipo, $indicacao);

        if($tipo == 'pedido'){

            $adegaViradaParticipanteId = $cliente->adegaViradaParticipante->id;

            //2º step - seed adega_virada_cupom_pedido
            $sql = "INSERT INTO adega_virada_cupom_pedido (adega_virada_cupom_id, pedido_venda_id) 
            SELECT 	
                {$adegaViradaCupom->id}, adega_virada_participante_pedido.pedido_venda_id
            FROM 
                adega_virada_participante_pedido
                INNER JOIN adega_virada_participante ON adega_virada_participante.id = adega_virada_participante_pedido.adega_virada_participante_id
            WHERE
                adega_virada_participante.cadastro_id = {$cliente->id}
                AND adega_virada_participante_pedido.situacao = 'P'
                AND adega_virada_participante_pedido.adega_virada_cupom_id IS NULL";
            DB::statement($sql);

            DB::table('adega_virada_participante_pedido')->where('adega_virada_participante_id', $adegaViradaParticipanteId)->where('situacao', 'P')->update(['situacao' => 'R', 'adega_virada_cupom_id' => $adegaViradaCupom->id]);

            DB::table('adega_virada_participante')->where('id', $adegaViradaParticipanteId)->update(['valor_pedidos_proximo_cupom' => 0]);

        }elseif($tipo == 'indicacao'){

            if($indicacao){
                DB::table('adega_virada_participante_indicacao')->where('id', $indicacao->id)->update(['situacao' => 'R', 'adega_virada_cupom_id' => $adegaViradaCupom->id]);
            }

            DB::table('adega_virada_cupom_indicacao')->insert([
                [
                    'adega_virada_cupom_id' => $adegaViradaCupom->id,
                    'cadastro_id'           => $cliente->id
                ]
            ]);

        }

        // last step - send mail cupom

        return true;

    }

    public static function queroParticipar($cadastroId = false, $input = false){
        $cadastro = $cadastroId ? Cadastro::where('id', $cadastroId)->first() : GeralService::buscarClienteLogado();
        $adegaViradaAtual = self::buscarAdegaVirada();
        
        if(!$cadastro)
            return (object)[
                'status' => false,
                'message' => 'Você precisa estar logado para participar.'
            ];

        if(!$adegaViradaAtual)
            return (object)[
                'status' => false,
                'message' => 'Não foi possível confirmar sua participação agora.'
            ];

        if(isset($cadastro->adegaViradaParticipante)){
            $adegaViradaParticipante = $cadastro->adegaViradaParticipante;
            $message = 'Participação atualizada!';
        }else{
            $adegaViradaParticipante = new AdegaViradaParticipante();
            $adegaViradaParticipante->adega_virada_id = $adegaViradaAtual->id;
            $adegaViradaParticipante->cadastro_id = $cadastro->id;
            $adegaViradaParticipante->codigo = GeralService::gerarCodigoAleatorio();
            $adegaViradaParticipante->data_cadastro = date('Y-m-d H:i:s');
            $message = 'Agora você está participando';
        }

        if(is_array($input) && isset($input['regulamento'])){
            $adegaViradaParticipante->aceite_regulamento = 1;
            $adegaViradaParticipante->data_aceite = date('Y-m-d H:i:s');
        }

        $adegaViradaParticipante->save();

        return (object)[
            'status' => true,
            'message' => 'Agora você está participando!'
        ];
    }

    public static function buscarCuponsCliente($cadastroId = false, $anoEdicao = false){
        $anoEdicao ? $anoEdicao : date('Y');
        $cadastro = $cadastroId ? Cadastro::where('id', $cadastroId)->first() : GeralService::buscarClienteLogado();

        $adegaViradaCupons = AdegaViradaCupom::select('adega_virada_cupom.*', 'adega_virada_participante_indicacao.nome_completo as nome_indicado')
        ->join('adega_virada_participante', 'adega_virada_participante.id', 'adega_virada_cupom.adega_virada_participante_id')
        ->join('adega_virada', 'adega_virada.id', 'adega_virada_participante.adega_virada_id')
        ->join('adega_virada_participante_indicacao', 'adega_virada_participante_indicacao.adega_virada_cupom_id', 'adega_virada_cupom.id')
        ->leftJoin('adega_virada_cupom_indicacao', 'adega_virada_cupom_indicacao.adega_virada_cupom_id', 'adega_virada_cupom.id')
        ->leftJoin('cadastro', 'cadastro.id', 'adega_virada_cupom_indicacao.cadastro_id')
        ->where('adega_virada_participante.cadastro_id', $cadastro->id)
        ->where('adega_virada.ano_edicao', $anoEdicao)
        ->where('adega_virada_cupom.tipo', 'indicacao')
        ->get();    

        return $adegaViradaCupons;
    }

    public static function buscarGanhador($anoEdicao){
        $adegaVirada = self::buscarAdegaVirada($anoEdicao, TRUE);

        $ganhador = Cadastro::select('cadastro.*')
        ->join('adega_virada_resultado', 'cadastro.id', 'adega_virada_resultado.cadastro_id_vencedor')
        ->where('adega_virada_resultado.adega_virada_id', $adegaVirada->id)
        ->with('user')
        ->first();

        return $ganhador;
    }

    public static function buscarParticipantes($anoEdicao, $removerGanhador = false){
        $adegaVirada = self::buscarAdegaVirada($anoEdicao, TRUE);

        $participantes = Cadastro::select('cadastro.*')
        ->join('adega_virada_participante', 'adega_virada_participante.cadastro_id', 'cadastro.id')
        ->leftJoin('adega_virada_cupom', 'adega_virada_cupom.adega_virada_participante_id', 'adega_virada_participante.id')
        ->where('adega_virada_participante.adega_virada_id', $adegaVirada->id)
        ->with('user');
        if($removerGanhador){
           $ganhador = self::buscarGanhador($anoEdicao);
           if($ganhador)
                $participantes->where('cadastro.id', '!=', $ganhador->id);
        }
        
        return $participantes->groupBy('cadastro.id')->get();
    }

    public static function enviarEmailResultado($anoEdicao){
        self::enviarEmailNaoGanhadores($anoEdicao);
        self::enviarEmailGanhador($anoEdicao);
        return;
    }

    public static function enviarEmailNaoGanhadores($anoEdicao){
        $participantes = self::buscarParticipantes($anoEdicao, true);

        if(count($participantes) == 0)
            return;

        $data['ultimasOfertas'] = AdegaViradaService::buscarOfertas($anoEdicao, false, 4)->toArray();
        // Divide o array em 2
        $ultimasOfertas = array_chunk($data['ultimasOfertas'], 2);
        $data['ofertas_1'] = array_key_exists('0', $ultimasOfertas) ? $ultimasOfertas[0] : [];
        $data['ofertas_2'] = array_key_exists('1', $ultimasOfertas) ? $ultimasOfertas[1] : [];


        foreach($participantes as $participante){
            $email = $participante->user->email;
            $data['cadastro'] = $participante;
            \Mail::send('emails.adega-virada.resultado_participantes', $data, function ($m) use ($data, $email){
                $m->from('no-reply@vinumday.com.br', 'Vinum Day');
                $m->to($email)->subject('Resultado Adega da Virada 2023');
            });
        }

        return true;
    }

    public static function enviarEmailGanhador($anoEdicao){
        $ganhador = self::buscarGanhador($anoEdicao);

        if(!$ganhador)
            return;

        $email = $ganhador->user->email;
        $data['cadastro'] = $ganhador;

        /*$data['ultimasOfertas'] = AdegaViradaService::buscarOfertas($anoEdicao, false, 4)->toArray();
        // Divide o array em 2
        $ultimasOfertas = array_chunk($data['ultimasOfertas'], 2);
        $data['ofertas_1'] = array_key_exists('0', $ultimasOfertas) ? $ultimasOfertas[0] : [];
        $data['ofertas_2'] = array_key_exists('1', $ultimasOfertas) ? $ultimasOfertas[1] : [];*/

        \Mail::send('emails.adega-virada.ganhador', $data, function ($m) use ($data, $email){
            $m->from('no-reply@vinumday.com.br', 'Vinum Day');
            $m->to($email)->subject('Você é o ganhador da Adega da Virada 2023!');
        });
    }


    // PARA QUEM INDICOU
    public static function enviarEmailLembreteRemetente(){
        $participantes = AdegaViradaParticipante::with('indicacoesPendentes', 'cadastro')->get();
        
        foreach($participantes as $participante){
            $data = [];
            $data['cadastro'] = $participante->cadastro;
            
            foreach($participante->indicacoesPendentes as $indicacaoPendente){
                $email = $indicacaoPendente->email;
                $data['nomeIndicado'] = $indicacaoPendente = $indicacaoPendente->nome_completo;
                
                \Mail::send('emails.adega-virada.lembrete_remetente', $data, function ($m) use ($data, $email){
                    $m->from('no-reply@vinumday.com.br', 'Vinum Day');
                    $m->to($email)->subject('Lembrete Adega Da Virada 2023!');
                });
            }
        }

      return;
    }

    // PARA O INDICADO
    public static function enviarEmailLembrete($adegaViradaParticipanteIndicacaoId){
        $indicacao = AdegaViradaParticipanteIndicacao::with('participante')->where('id', $adegaViradaParticipanteIndicacaoId)->first();

        $email = $indicacao->email;
        $data['cadastro'] = Cadastro::where('id', $indicacao->participante->cadastro_id)->first();
        $data['nomeIndicado'] = $indicacao->nome_completo;

        $anoEdicao = 2022;
        $data['ultimasOfertas'] = AdegaViradaService::buscarOfertas($anoEdicao, false, 4)->toArray();
        // Divide o array em 2
        $ultimasOfertas = array_chunk($data['ultimasOfertas'], 2);
        $data['ofertas_1'] = array_key_exists('0', $ultimasOfertas) ? $ultimasOfertas[0] : [];
        $data['ofertas_2'] = array_key_exists('1', $ultimasOfertas) ? $ultimasOfertas[1] : [];

        \Mail::send('emails.adega-virada.lembrete_indicado', $data, function ($m) use ($data, $email){
            $m->from('no-reply@vinumday.com.br', 'Vinum Day');
            $m->to($email)->subject('Lembrete Adega Da Virada 2023!');
        });
    }

    public static function regulamentoStatus($cadastroId = false){
        $cadastro = $cadastroId ? Cadastro::where('id', $cadastroId)->first() : GeralService::buscarClienteLogado();

        if($cadastro && $cadastro->adegaViradaParticipante && $cadastro->adegaViradaParticipante->aceite_regulamento == true)
            return true;

        return false;
    }

    public static function buscarIndicacoes($cadastroId = false){
        $cadastro = $cadastroId ? Cadastro::where('id', $cadastroId)->first() : GeralService::buscarClienteLogado();

        if(!$cadastro->adegaViradaParticipante)
            return [];

        $indicacoes = AdegaViradaParticipanteIndicacao::select('adega_virada_participante_indicacao.*')
            ->where('adega_virada_participante_indicacao.adega_virada_participante_id', $cadastro->adegaViradaParticipante->id)
            ->whereRaw("(cadastro_id IS NULL OR cadastro_id <> {$cadastro->id})")
        ->get();

        return $indicacoes;
    }

}