<?php

namespace App\Http\Controllers\Api;

use Validator;

use App\Http\Requests;
//use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use App\Http\Requests\LoginFormRequest;
use Illuminate\Support\Facades\Log;
use Sentinel;
use Dingo\Api\Routing\Helpers;
use Illuminate\Routing\Controller;
use Mail;
use App\User;
use App\Modules\Condominos\Models\Condominos;
use App\Modules\Recado\Models\Recado;
use App\Modules\Aviso\Models\Aviso;
use App\Modules\Questionamento\Models\Questionamento;
use App\Modules\QuestionamentoAssunto\Models\QuestionamentoAssunto;
use App\Modules\QuestionamentoResposta\Models\QuestionamentoResposta;
use App\Modules\Animal\Models\Animal;
use App\Modules\Veiculo\Models\Veiculo;
use App\Modules\TipoAnimal\Models\TipoAnimal;
use App\Modules\EspacoComum\Models\EspacoComum;
use App\Modules\EspacoComumTipo\Models\EspacoComumTipo;
use App\Modules\EspacoComumModelo\Models\EspacoComumModelo;
use App\Modules\EspacoComumItensModelo\Models\EspacoComumItensModelo;
use App\Modules\EspacoComumItens\Models\EspacoComumItens;
use App\Modules\EspacoComumHorario\Models\EspacoComumHorario;
use App\Modules\EventoPrivadoConvidado\Models\EventoPrivadoConvidado;
use App\Modules\ReservaConvidado\Models\ReservaConvidado;
use App\Modules\Convidado\Models\Convidado;
use App\Modules\Reserva\Models\Reserva;
use App\Modules\EventoPrivado\Models\EventoPrivado;
use App\Modules\ConfiguracaoNotificacao\Models\ConfiguracaoNotificacao;
use App\Modules\Notificacao\Models\Notificacao;
use App\Modules\Documento\Models\Documento;
use App\Modules\Condominio\Models\Condominio;
use App\Modules\CondominioUnidade\Models\CondominioUnidade;
use App\Modules\Cidade\Models\Cidade;
use App\Modules\Estado\Models\Estado;
use App\Services\CondominioService;


use App\Modules\EnqueteAlternativaUsers\Models\EnqueteAlternativaUsers;
use App\Modules\Post\Models\Post;
use App\Modules\Evento\Models\Evento;

use App\Modules\Enquete\Models\Enquete;
use App\Modules\EnqueteAlternativa\Models\EnqueteAlternativa;
use App\Modules\CondominioTorre\Models\CondominioTorre;
use App\Modules\PrestadordeServico\Models\PrestadordeServico;
use App\Modules\SegmentoServico\Models\SegmentoServico;
use App\Modules\Assembleia\Models\Assembleia;
use App\Modules\AssembleiaCondominioTorre\Models\AssembleiaCondominioTorre;
use App\Modules\AssembleiaQuestionamento\Models\AssembleiaQuestionamento;
use App\Modules\Segmento\Models\Segmento;
use App\Modules\Empresa\Models\Empresa;
use App\Modules\PostLike\Models\PostLike;
use App\Modules\Pessoa\Models\Pessoa;
use App\Modules\PessoaSegmento\Models\PessoaSegmento;
use App\Modules\Politicas\Models\Politicas;
use App\Modules\Cupom\Models\Cupom;
use App\Modules\CupomPessoa\Models\CupomPessoa;
use App\Modules\PerguntasFrequentes\Models\PerguntasFrequentes;
use App\Modules\RecadoDestinatario\Models\RecadoDestinatario;

use App\Modules\PessoaAutorizada\Models\PessoaAutorizada;
use App\Modules\RecadoResposta\Models\RecadoResposta;
use App\Modules\HistoricoSindico\Models\HistoricoSindico;
use App\Modules\MotivoTrocaSindico\Models\MotivoTrocaSindico;

use App\Modules\AcessoUsuario\Models\AcessoUsuario;

use Notification;
use App\Notifications\NotificacaoContato;

use Activation;
use DB;

class ApiController extends Controller
{
	use Helpers;

	public function __construct(){
		setlocale(LC_ALL, 'pt_BR', 'pt_BR.utf-8', 'pt_BR.utf-8', 'portuguese');
		date_default_timezone_set('America/Sao_Paulo');
	}

	/**
	* Show the form for creating a new resource.
	*
	* @return Response
	*/
	public function teste()
	{
		//return view('admin.sessions.create');

		$user = app('Dingo\Api\Auth\Auth')->user();

		return $user;
	}

	public function sindicoLogin(){
		$params = \Request::input();
		$response = null;
		if(User::join('sis_role_users', 'sis_users.id', '=', 'sis_role_users.user_id')->where('sis_role_users.role_id', 2)->where('email', $params['email'])->count()){
			$user = Sentinel::authenticate(array(
				'email'    => $params['email'],
				'password' => $params['password']
			));
			if($user){
				$response = $user;
				$status = true;
				$message = 'Usuário logado com sucesso.';
			}else{
				$status = false;
				$message = 'Não foi possível efetuar o login. E-mail ou senha inválidos.';
			}
		}else{
			$status = false;
			$message = 'Não existe um usuário com esse e-mail';
		}

		if($response){
			$condomino = Condominos::where('id_user', $response->id)->first();
			$response->id_user = $response->id;
			$response->id = $condomino->id;
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}


	public function login(){
		$params = \Request::input();
		$response = null;
		if(isset($params['id_condominio'])){
			if(User::join('sis_role_users', 'sis_users.id', '=', 'sis_role_users.user_id')->join('condomino', 'sis_users.id_condomino' , '=', 'condomino.id')->join('condominio_unidade', 'condomino.id_condominio_unidade', '=', 'condominio_unidade.id')->join('condominio_torre', 'condominio_unidade.id_condominio_torre', '=', 'condominio_torre.id')->where('sis_users.email', $params['email'])->where('condominio_torre.id_condominio', $params['id_condominio'])->count()){
				$user = Sentinel::authenticate(array(
					'email'    => $params['email'],
					'password' => $params['password']
				));

				if($user){

					$userModel = \App\User::find($user->id);
					if(isset($params['udid']) && $params['udid']){
						$userModel->udid = $params['udid'];
						$userModel->save();
					}
					$notificacoes = ConfiguracaoNotificacao::where('configuracao_notificacao.id_user',$user->id)->get();
					$user->notificacoes = $notificacoes;
					$user->udid = $userModel->udid;
					$user->role = $userModel->roleUser->role;
					$user->permissions = str_replace('.','_',$user->permissions);
					$response = $user;
					$status = true;
					$message = 'Usuário logado com sucesso.';
				}else{
					$status = false;
					$message = 'Não foi possível efetuar o login. E-mail ou senha inválidos.';
				}
			}else{
				$status = false;
				$message = 'Não foi possível efetuar o login. Usuário não encontrado para esse condomínio.';
			}
		}else{
			$status = false;
			$message = 'É necessário enviar o código do condomínio.';
		}


		if($response){
			$condomino = Condominos::select('condomino.*')->join('sis_users', 'condomino.id', '=', 'sis_users.id_condomino')->where('sis_users.id', $response->id)->first();
			$response->id_user = $response->id;
			$response->id = $condomino->id;
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}


	public function buscarEventos()
	{

		$filtros = \Request::input();

		//var_dump($filtros); exit;


		$query = Evento::select('evento.*');
		if(isset($filtros['id_evento'])){
			$query->where('id', $filtros['id_evento']);
		}

		if(isset($filtros['status'])){
			$query->where('status', $filtros['status']);
		}

		if(isset($filtros['id_condominio_torre'])){
			$query->where('id_condominio_torre', $filtros['id_condominio_torre']);
		}

		if(isset($filtros['ano']) && isset($filtros['mes']) && isset($filtros['dia'])){
			$dataParametro = $filtros['ano'] . '-' . $filtros['mes'] . '-' . $filtros['dia'];
			$query->whereBetween('data', [$dataParametro . ' 00:00:00', $dataParametro . ' 23:59:59']);
		}


		$listaEventos = $query->get();

		foreach ($listaEventos as $key => $evento) {
			$flagCurtido = false;

			if($evento->id_user_responsavel){
				$listaEventos[$key]->userresponsavel = User::find($evento->id_user_responsavel);
				/*
				if($listaEventos[$key]->userresponsavel){
				$listaPosts[$key]->empresa->thumbnail_principal = url('/uploads/empresa/'.$listaPosts[$key]->empresa->thumbnail_principal);
			}
			*/
			}
			if($listaEventos[$key]->data){
				$listaEventos[$key]->data = date('d/m/Y H:i:s', strtotime($evento->data));
			}

		}

		return $listaEventos;
	}

	public function buscarRecados()
	{

		$filtros = \Request::input();
		$query = Recado::select('recado.*')->orderBy('recado.data', 'desc')->groupBy('recado.id');

		if(isset($filtros['limit'])){
			$query->limit($filtros['limit']);
		}

		if(isset($filtros['id_recado'])){
			$query->where('recado.id', $filtros['id_recado']);
		}

		if(isset($filtros['tipo'])){
			$query->where('recado.tipo', $filtros['tipo']);
		}

		if(isset($filtros['hoje'])){
			$query->where('recado.data', '>=', date('Y-m-d H:i:s', strtotime('now -1 day')));
			$query->where('recado.data', '<=', date('Y-m-d H:i:s'));
		}

		if(isset($filtros['id_user_remetente'])){
			$query->where('recado.id_user_remetente', $filtros['id_user_remetente']);
		}

		if(isset($filtros['id_user'])){
			$query->join('recado_destinatario', 'recado.id', '=', 'recado_destinatario.id_recado');
			$query->where(function($q) use ($filtros){
				$q->where('recado_destinatario.id_user_destinatario', $filtros['id_user'])
				->orWhere('recado.id_user_remetente', $filtros['id_user']);
			});
		}

		$listaRecados = $query->get();
		if(isset($filtros['id_recado'])){
			$listaRecados->load(['respostas' => function ($query) {
			   $query->orderBy('data', 'desc');
			}, 'respostas.remetente.condomino']);
		}
		foreach ($listaRecados as $key => $recado) {

			if($recado->id_user_remetente){
				$userremetente = User::find($recado->id_user_remetente);
				$listaRecados[$key]->first_name = $userremetente->first_name;
				$listaRecados[$key]->last_name = $userremetente->last_name;
				$listaRecados[$key]->thumbnail = $userremetente->thumbnail_principal;
			}

			if($recado->data){
				$listaRecados[$key]->data = date('d/m/Y', strtotime($recado->data));
			}

			if($recado->tipo){
				if ($recado->tipo == 'E') $listaRecados[$key]->tipo_string = 'Evento';
				if ($recado->tipo == 'A') $listaRecados[$key]->tipo_string = 'Aviso';
				if ($recado->tipo == 'S') $listaRecados[$key]->tipo_string = 'Solicitação';
			}

			$listaRecados[$key]->descricao = str_replace('src="','src="'.url(''), $recado->descricao);

		}

		return $listaRecados;
	}

	public function buscarDocumentos()
	{

		$filtros = \Request::input();
		$query = Documento::select('documento.*')->orderBy('documento.data_criacao', 'desc')->orderBy('documento.data_modificacao', 'desc')->groupBy('documento.id');
		if(isset($filtros['id_documento'])){
			$query->where('documento.id', $filtros['id_documento']);
		}

		if(isset($filtros['id_user_criacao'])){
			$query->where('documento.id_user_criacao', $filtros['id_user_criacao']);
		}

		if(isset($filtros['id_user_modificacao'])){
			$query->where('documento.id_user_modificacao', $filtros['id_user_modificacao']);
		}

		if(isset($filtros['id_condominio'])){
			$query->where('documento.id_condominio', $filtros['id_condominio']);
		}
		$query->where('documento.status', 'A');

		$listaDocumentos = $query->with('categoria', 'condominio', 'userCriacao', 'userModificacao')->get();

		return $listaDocumentos;
	}

	public function buscarReservas()
	{

		$filtros = \Request::input();
		$query = Reserva::select('reserva.*')->orderBy('reserva.data', 'desc')->groupBy('reserva.id');
		if(isset($filtros['id_reserva'])){
			$query->where('reserva.id', $filtros['id_reserva']);
		}

		if(isset($filtros['id_user_responsavel'])){
			$query->where('reserva.id_user_responsavel', $filtros['id_user_responsavel']);
		}

		if(isset($filtros['status'])){
			$query->where('reserva.status', $filtros['status']);
		}

		if(isset($filtros['data'])){
			$query->where('reserva.data', '>=', $filtros['data']);
		}

		$listaReservas = $query->get();

		foreach ($listaReservas as $key => $reserva) {
			$reserva->convidados;
			$reserva->condominioUnidade;
			$reserva->espacoComumHorario;
			$reserva->espacoComum;
			$reserva->userResponsavel;
			if ($reserva->status == 'P') $listaReservas[$key]->status_string = 'Pendente';
			if ($reserva->status == 'A') $listaReservas[$key]->status_string = 'Aprovada';
			if ($reserva->status == 'R') $listaReservas[$key]->status_string = 'Recusada';
		}

		return $listaReservas;
	}

	public function buscarAvisos()
	{

		$filtros = \Request::input();
		$query = Aviso::select('aviso.*')->orderBy('aviso.data', 'desc');
		$query->where('status', 'A');

		if(isset($filtros['id_aviso'])){
			$query->where('id_aviso', $filtros['id_aviso']);
		}

		if(isset($filtros['id_user_destinatario'])){
			$query->where('id_user_destinatario', $filtros['id_user_destinatario']);
		}

		if(isset($filtros['hoje'])){
			$query->where(function($q){
				$q->where('data', '>=', date('Y-m-d H:i:s'))
				->where('data', '<=', date('Y-m-d H:i:s', strtotime('+1 day')));
			});
		}

		$listaAvisos = $query->get();

		foreach ($listaAvisos as $key => $aviso) {

			if($aviso->id_user_remetente){
				$listaAvisos[$key]->userremetente = User::find($aviso->id_user_remetente);
			}

			if($aviso->data){
				$listaAvisos[$key]->data = date('d/m/Y', strtotime($aviso->data));
			}

		}

		return $listaAvisos;
	}

	public function buscarQuestionamentos()
	{

		$filtros = \Request::input();
		$offset = (isset($filtros['offset'])) ? $filtros['offset'] : 0;
		$limit = (isset($filtros['limit'])) ? $filtros['limit'] : 10;

		$query = Questionamento::select(array('questionamento.*', 'questionamento_assunto.nome'))->orderBy('questionamento.data_criacao', 'DESC')->limit($limit);

		$query->join('questionamento_assunto', 'questionamento_assunto.id', '=', 'questionamento.id_questionamento_assunto');

		if(isset($filtros['id_questionamento'])){
			$query->where('questionamento.id', $filtros['id_questionamento']);
		}

		if(isset($filtros['id_user_destinatario'])){
			$query->where('questionamento.id_user_destinatario', $filtros['id_user_destinatario']);
		}

		if(isset($filtros['visualizado'])){
			$query->where('questionamento.visualizado', $filtros['visualizado']);
		}

		if(isset($filtros['id_user_remetente'])){
			$query->where('questionamento.id_user_remetente', $filtros['id_user_remetente']);
		}

		if(isset($filtros['tipo'])){
			$query->where('questionamento.tipo', $filtros['tipo']);
		}

		if(isset($filtros['status'])){
			$query->where('questionamento.status', $filtros['status']);
		}

		if(isset($filtros['id_condominio'])){
			$query->join('sis_users','questionamento.id_user_destinatario', '=', 'sis_users.id');
			$query->join('condomino','sis_users.id_condomino', '=', 'condomino.id');
			$query->join('condominio_unidade','condomino.id_condominio_unidade', '=', 'condominio_unidade.id');
			$query->join('condominio_torre','condominio_unidade.id_condominio_torre', '=', 'condominio_torre.id');
			$query->where('condominio_torre.id_condominio', $filtros['id_condominio']);
		}


		$listaQuestionamentos = $query->get();

		if(isset($filtros['id_questionamento'])){
			$listaQuestionamentos->load(['respostas' => function ($q) {
			   $q->orderBy('questionamento_resposta.data', 'desc');
			}, 'respostas.sindico']);
		}

		$questionamentosPendentes = [];
		$questionamentosFinalizadosOuAssembleia = [];
		$count = 0;
		foreach ($listaQuestionamentos as $key => $questionamento) {

			if($questionamento->id_user_remetente){
				$userremetente = User::find($questionamento->id_user_remetente);
				$listaQuestionamentos[$key]->first_name = $userremetente->first_name;
				$listaQuestionamentos[$key]->last_name = $userremetente->last_name;
				$listaQuestionamentos[$key]->thumbnail_user = $userremetente->thumbnail_principal;
			}

			if($questionamento->data){
				$listaQuestionamentos[$key]->data = date('d/m/Y', strtotime($questionamento->data));
			}

			if($questionamento->tipo){
				if ($questionamento->tipo == 'R') $listaQuestionamentos[$key]->tipo_string = 'Reclamação';
				if ($questionamento->tipo == 'S') $listaQuestionamentos[$key]->tipo_string = 'Sugestão';
			}

			/*foreach ($questionamento->respostas as $resposta) {
				$resposta->sindico;
			}*/

			if($questionamento->status){
				if ($questionamento->status == 'P'){
					$listaQuestionamentos[$key]->status_string = 'Pendente';
					$questionamentosPendentes[] = $questionamento;
				}
				if ($questionamento->status == 'F'){
					$listaQuestionamentos[$key]->status_string = 'Finalizado';
					if($count < $limit && $count >= $offset){
						$questionamentosFinalizadosOuAssembleia[] = $questionamento;
						$count++;
					}
				}
				if ($questionamento->status == 'A'){
					$listaQuestionamentos[$key]->status_string = 'Discutir em Assembléia';
					if($count < $limit && $count >= $offset){
						$questionamentosFinalizadosOuAssembleia[] = $questionamento;
						$count++;
					}
				}
			}
		}

		if(isset($filtros['id_questionamento'])){
			return $listaQuestionamentos;
		}else {
			return json_encode(array(
				'questionamentos_pendentes' => $questionamentosPendentes,
				'questionamentos_assembleia_finalizados' => $questionamentosFinalizadosOuAssembleia
			));
		}

	}

	public function buscarNotificacoes()
	{

		$filtros = \Request::input();
		$offset = (isset($filtros['offset'])) ? $filtros['offset'] : 0;

		$query = Notificacao::select(array('notificacao.*'))->orderBy('notificacao.status', 'ASC')->orderBy('notificacao.data_criacao', 'DESC')->groupBy('notificacao.id');

		if(isset($filtros['limit'])){
			$query->limit($filtros['limit']);
		}

		if(isset($filtros['id_notificacao'])){
			$query->where('notificacao.id', $filtros['id_notificacao']);
		}

		if(isset($filtros['status'])){
			$query->where('notificacao.status', $filtros['status']);
		}

		if(isset($filtros['id_user_destinatario'])){
			$query->where('notificacao.id_user_destinatario', $filtros['id_user_destinatario']);
		}

		if(isset($filtros['id_user_remetente'])){
			$query->where('notificacao.id_user_remetente', $filtros['id_user_remetente']);
		}

		$listaNotificacoes = $query->get();

		foreach ($listaNotificacoes as $key => $notificacao) {
			$user = User::find($notificacao->id_user_remetente);
			$listaNotificacoes[$key]->first_name = $user->first_name;
			$listaNotificacoes[$key]->last_name = $user->last_name;
			$listaNotificacoes[$key]->thumbnail = $user->thumbnail_principal;

		}


		return $listaNotificacoes;

	}

	public function buscarTorres()
	{

		$filtros = \Request::input();
		$query = CondominioTorre::select(array('condominio_torre.*'))->orderBy('condominio_torre.nome', 'ASC');

		$query->join('condominio', 'condominio_torre.id_condominio', '=', 'condominio.id');

		if(isset($filtros['id_condominio'])){
			$query->where('condominio.id', $filtros['id_condominio']);
		}

		$listaTorres = $query->get();


		foreach ($listaTorres as $key => $torre) {
			$torre->unidades;
			$torre->condominio;
		}

		$status = true;
		$message = 'Segue listagem  de torres';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $listaTorres
		));


		//return $listaTorres;
	}

	public function buscarEspacosComuns()
	{

		$filtros = \Request::input();
		$query = EspacoComum::select(array('espaco_comum.*'))->orderBy('espaco_comum.nome', 'ASC');
		$query->join('condominio', 'espaco_comum.id_condominio', '=', 'condominio.id');

		if(isset($filtros['id_condominio'])){
			$query->where('condominio.id', $filtros['id_condominio']);
		}

		$listaEspacos = $query->get();

		foreach ($listaEspacos as $key => $espaco) {
			$espaco->items;
		}

		return $listaEspacos;
	}

	public function buscarEspacoComum(Request $request)
	{
		$post = $request->input();

		$espacoComum = EspacoComum::with('items', 'horarios', 'reservas', 'tipo', 'condominio')->find($post['id_espaco_comum']);

		if($espacoComum){
			return $espacoComum;
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não existe um espaço comum com esse ID'
			));
		}

	}

	public function buscarAssembleias()
	{

		$filtros = \Request::input();

		if(!isset($filtros['id_condominio']) || !$filtros['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_condominio é obrigatório'
			));
		}


		$offset = isset($filtros['offset']) ? $filtros['offset'] : 0;
		$limit = isset($filtros['limit']) ? $filtros['limit'] : 10;
		$countFinalizadas = 0;
		$query = Assembleia::select(array('assembleia.*'))->orderBy('assembleia.data_primeira_chamada', 'DESC');
		if(isset($filtros['id_assembleia'])){
			$query->where('assembleia.id', $filtros['id_assembleia']);
		}
		if(isset($filtros['id_condominio'])){
			$query->join('assembleia_condominio_torre', 'assembleia.id', '=', 'assembleia_condominio_torre.id_assembleia');
			$query->join('condominio_torre', 'assembleia_condominio_torre.id_condominio_torre', '=', 'condominio_torre.id');
			$query->where('condominio_torre.id_condominio', $filtros['id_condominio']);
			$query->groupBy('assembleia.id');
		}

		$listaAssembleias = $query->get();


		$assembleiasFinalizadas = [];
		$assembleiasAbertas = [];
		foreach ($listaAssembleias as $key => $assembleia) {
			foreach ($assembleia->torres as $assembleiaTorre) {
				$assembleiaTorre->torre;
			}
			foreach ($assembleia->questionamentos as $assembleiaQuestionamento) {
				$assembleiaQuestionamento->questionamento;
			}
			if($assembleia->status){
				$assembleiasAbertas[] = $assembleia;
			}else{
				if($countFinalizadas >= $offset && $countFinalizadas < $limit){
					$assembleiasFinalizadas[] = $assembleia;
					$countFinalizadas++;
				}
			}
		}

		if(isset($filtros['id_assembleia'])){
			return $listaAssembleias;
		}else{
			return json_encode(array(
				'assembleias_finalizadas' => $assembleiasFinalizadas,
				'assembleias_abertas' => array_reverse($assembleiasAbertas)
			));
		}
	}

	public function buscar_posts()
	{

		$filtros = \Request::input();
		$query = Post::select('post.*');
		if(isset($filtros['id_post'])){
			$query->where('id', $filtros['id_post']);
		}
		$listaPosts = $query->get();

		foreach ($listaPosts as $key => $post) {
			$flagCurtido = false;
			foreach ($post->postLikes as $postLike) {
				$postLike->pessoaObject;
			}
			if($post->id_segmento){
				$listaPosts[$key]->segmento = Segmento::find($post->id_segmento);
			}
			if($post->id_empresa){
				$listaPosts[$key]->empresa = Empresa::find($post->id_empresa);
				if($listaPosts[$key]->empresa){
					$listaPosts[$key]->empresa->thumbnail_principal = url('/uploads/empresa/'.$listaPosts[$key]->empresa->thumbnail_principal);
				}
			}
			if($listaPosts[$key]->data){
				$listaPosts[$key]->data = date('d/m/Y', strtotime($post->data));
			}
			if($listaPosts[$key]->data_validade){
				$listaPosts[$key]->data_validade = date('d/m/Y', strtotime($post->data_validade));
			}
			if($listaPosts[$key]->thumbnail_principal){
				$listaPosts[$key]->thumbnail_principal = url('/uploads/post/'.$post->thumbnail_principal);
			}
			if(isset($filtros['id_pessoa'])){
				foreach ($post->postLikes as $postLike) {
					if($postLike->pessoaObject->id == $filtros['id_pessoa']){
						$flagCurtido = true;
					}
				}
			}
			$listaPosts[$key]->curtido = $flagCurtido;
		}

		return $listaPosts;
	}

	public function buscarEmpresas()
	{
		$filtros = \Request::input();
		$query = Empresa::select('empresa.*');

		if(isset($filtros['id_segmento'])){
			$arraySegmento = explode(',',$filtros['id_segmento']);
			$query->join('empresa_has_segmento', 'empresa.id', '=', 'empresa_has_segmento.id_empresa');
			//$query->where('empresa_has_segmento.id_segmento', $filtros['id_segmento']);
			$query->whereIn('empresa_has_segmento.id_segmento', $arraySegmento);
			$query->groupBy('empresa.id');
		}

		$listaEmpresas = $query->get();

		foreach ($listaEmpresas as $key => $empresa) {

			foreach ($empresa->segmentos as $segmento) {
				$segmento->objSegmento;
			}

			if($listaEmpresas[$key]->thumbnail_principal){
				$listaEmpresas[$key]->thumbnail_principal = url('/uploads/empresa/'.$empresa->thumbnail_principal);
			}

			if($listaEmpresas[$key]->thumbnail_logo){
				$listaEmpresas[$key]->thumbnail_logo = url('/uploads/empresa/'.$empresa->thumbnail_logo);
			}

		}

		return $listaEmpresas->toJson();
	}

	public function getPost()
	{

		$filtros = \Request::input();
		$flagDisponivel = false;
		$flagCurtido = false;

		$post = Post::with('cupons')->find($filtros['id_post']);

		$post->segmento;
		if($post->empresa){
			$post->empresa->thumbnail_principal = url('/uploads/empresa/'.$post->empresa->thumbnail_principal);
		}
		if($post->data){
			$post->data = date('d/m/Y', strtotime($post->data));
		}
		if($post->data_validade){
			$post->data_validade = date('d/m/Y', strtotime($post->data_validade));
		}
		if($post->thumbnail_principal){
			$post->thumbnail_principal = url('/uploads/post/'.$post->thumbnail_principal);
		}

		if(count($post->cuponsAbertosDisponiveis)){
			$flagDisponivel = true;
		}
		if(isset($filtros['id_pessoa'])){
			foreach ($post->cupons as $cupom) {
				if($cupom->cupomPessoa && $cupom->cupomPessoa->pessoaObject && $cupom->cupomPessoa->pessoaObject->id == $filtros['id_pessoa']){
					$flagDisponivel = false;
				}
			}
			foreach ($post->postLikes as $postLike) {
				if($postLike->pessoaObject->id == $filtros['id_pessoa']){
					$flagCurtido = true;
				}
			}
		}
		$post->cupomDisponivel = $flagDisponivel;
		$post->curtido = $flagCurtido;

		return $post->toJson();
	}

	public function buscarSegmentos()
	{
		$filtros = \Request::input();
		$query = Segmento::select('segmento.*');

		if(isset($filtros['id_segmento'])){
			$query->whereIn('segmento.id', $filtros['id_segmento']);
		}

		$listaSegmentos = $query->get();


		return $listaSegmentos;
	}

	public function inserirPostLike()
	{
		$filtros = \Request::input();
		$obj = new PostLike;

		if($obj->validate($filtros)){
			$obj->id_post = $filtros['id_post'];
			$obj->id_pessoa = $filtros['id_pessoa'];
			$obj->data = date('Y-m-d H:i:s');
			$obj->save();
			return json_encode(array("retorno" => true));
		}else{
			return json_encode(array("retorno" => false));
		}

	}

	public function removerPostLike()
	{
		$filtros = \Request::input();

		$obj = PostLike::where('id_post', $filtros['id_post'])
		->where('id_pessoa', $filtros['id_pessoa'])
		->delete();

		return json_encode(array("retorno" => true));

	}

	public function inserirPessoa(){
		return json_encode(array("retorno" => false));
		$info = \Request::input();
		$password = $info['password'];
		unset($info['password']);
		unset($info['confirmPassword']);
		$pessoa = Pessoa::find(DB::table('pessoa')->insertGetId($info));
		$user = Sentinel::register(array(
			'first_name' => $info['nome'],
			'email'    => $info['email'],
			'password' => $password,
		));
		$pessoa->id_user = $user->id;
		$pessoa->save();
		$role = Sentinel::findRoleById(1);
		$role->users()->attach($user);
		$activation = Activation::create($user);
		Activation::complete($user, $activation->code);

		$pessoa->cidade;
		$pessoa->grupoPessoa;

		return $pessoa;
	}

	public function inserirPessoaSegmento(){
		$post = \Request::input();
		$pessoa = Pessoa::find($post['id_pessoa']);
		foreach ($pessoa->segmentos as $segmento) {
			$segmento->delete();
		}
		foreach ($post['segmentos'] as $id_segmento) {
			$pessoaSegmento = new PessoaSegmento();
			$pessoaSegmento->id_pessoa = $pessoa->id;
			$pessoaSegmento->id_segmento = $id_segmento;
			$pessoaSegmento->save();
		}

		return json_encode(array('sucess' => true));
	}

	public function buscarSegmentosPessoa(){
		$post = \Request::input();
		$pessoa = Pessoa::find($post['id_pessoa']);

		$segmentos = Segmento::get();
		$segmentosPessoaArray = [];
		$returnArray = [];
		foreach ($pessoa->segmentos as $pessoaSegmento) {
			$segmentosPessoaArray[] = $pessoaSegmento->id_segmento;
		}
		foreach ($segmentos as $key => $segmento) {
			$returnArray['segmentos'][$key]['segmento'] = $segmento;
			if(in_array($segmento->id, $segmentosPessoaArray)){
				$returnArray['segmentos'][$key]['checked'] = true;
			}else{
				$returnArray['segmentos'][$key]['checked'] = false;
			}
		}

		return json_encode($returnArray);
	}

	public function buscarPoliticas(){
		$politicas = Politicas::get();
		return $politicas;
	}

	public function buscarPerguntasFrequentes(){
		$faq = PerguntasFrequentes::get();
		return $faq;
	}

	public function buscaReceberNotificacoes(){
		$post = \Request::input();
		$pessoa = Pessoa::find($post['id_pessoa']);
		$user = Sentinel::findUserById($pessoa->id_user);
		if($user->receber_notificacoes){
			return json_encode(array('receber_notificacoes' => true));
		}else{
			return json_encode(array('receber_notificacoes' => false));
		}
	}

	public function updateReceberNotificacoes(){
		$post = \Request::input();
		$pessoa = Pessoa::find($post['id_pessoa']);
		$user = User::find($pessoa->id_user);
		$user->receber_notificacoes = $post["receber_notificacoes"];
		$user->save();

		return json_encode(array(
			"status" => true
		));
	}

	public function buscaEmpresaHorarios(){
		$post = \Request::input();
		$empresa = Empresa::find($post['id_empresa']);
		if($empresa){
			return $empresa->horarios;
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não existe empresa com esse ID'
			));
		}
	}

	public function insereCupomPessoa(){
		$post = \Request::input();

		$postModel = Post::find($post['id_post']);
		$pessoa = Pessoa::find($post['id_pessoa']);
		$response = null;
		if(count($postModel->cuponsAbertosDisponiveis)){
			$cupom = $postModel->cuponsAbertosDisponiveis[0];
			if($cupom->data_validade >= date('Y-m-d')){
				if(!$cupom->cupomPessoa){
					if($cupom->status == 'A'){
						$cupomPessoa = new CupomPessoa();
						$cupomPessoa->id_pessoa = $post['id_pessoa'];
						$cupomPessoa->id_cupom = $cupom->id;
						$cupomPessoa->save();
						$status = true;
						$message = 'Cupom obtido com sucesso.';
						$response = $cupomPessoa->cupomObject;
					}else{
						$status = false;
						$message = 'O cupom não está mais em aberto.';
					}
				}else{
					$status = false;
					$message = 'O cupom já foi obtido por outra pessoa.';
				}
			}else{
				$status = false;
				$message = 'A data de validade do cupom já expirou.';
			}
		}else{
			$status = false;
			$message = 'O post não possui cupons abertos e não expirados.';
		}
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarEmpresa(){
		$params = \Request::input();
		$empresa = Empresa::find($params['id_empresa']);

		foreach ($empresa->posts as $post) {
			$post->curtido = false;
			if($post->data){
				$post->data = date('d/m/Y',strtotime($post->data));
			}
			if($post->thumbnail_principal){
				$post->thumbnail_principal = url('/uploads/post/'.$post->thumbnail_principal);
			}
			if(isset($params['id_pessoa'])){
				foreach ($post->postLikes as $postLike) {
					if($postLike->pessoaObject->id == $params['id_pessoa']){
						$post->curtido = true;
					}
				}
			}
		}
		$empresa->filiais;
		foreach ($empresa->segmentos as $segmento) {
			$segmento->objSegmento;
		}
		$horarios = [];
		foreach ($empresa->horarios as $horario) {
			if($horario->dia == date('w') + 1){
				$horarios[] = $horario;
			}
		}
		$empresa->horariosDiaAtual = $horarios;
		if($empresa->thumbnail_principal){
			$empresa->thumbnail_principal = url('/uploads/empresa/'.$empresa->thumbnail_principal);
		}
		if($empresa->thumbnail_logo){
			$empresa->thumbnail_logo = url('/uploads/empresa/'.$empresa->thumbnail_logo);
		}
		return $empresa->toJson();
	}

	public function buscarCupom(){
		$post = \Request::input();
		$cupom = Cupom::find($post['id_cupom']);
		$response = null;

		if($cupom){
			$cupom->data_validade = date('d/m/Y',strtotime($cupom->data_validade));
			$cupom->grupoPessoa;
			$cupom->post;
			if($cupom->cupomPessoa){
				$cupom->cupomPessoa->pessoaObject;
			}
			if($cupom->valor_desconto == 0.00){
				$cupom->valor_desconto = null;
			}
			if($cupom->percentual_desconto == 0.00){
				$cupom->percentual_desconto = null;
			}
			$response = $cupom;
			$status = true;
			$message = 'Cupom buscado com sucesso.';
		}else{
			$message = 'Não existe um cupom com esse ID';
			$status = false;
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarCupons(){
		$post = \Request::input();
		$pessoa = Pessoa::find($post['id_pessoa']);
		$response = null;

		if($pessoa){
			$response = array();
			foreach ($pessoa->cupons as $cupomPessoa) {
				$cupom = $cupomPessoa->cupomObject;
				$cupom->data_validade = date('d/m/Y',strtotime($cupom->data_validade));
				if($cupom->post->empresa){
					$cupom->post->data = date('d/m/Y',strtotime($cupom->post->data));
					if($cupom->post->empresa->thumbnail_logo)
					$cupom->post->empresa->thumbnail_logo = url('/uploads/empresa/'.$cupom->post->empresa->thumbnail_logo);
					if($cupom->post->empresa->thumbnail_principal)
					$cupom->post->empresa->thumbnail_principal = url('/uploads/empresa/'.$cupom->post->empresa->thumbnail_principal);
				}

				$response[] = $cupomPessoa->cupomObject;
			}
			$message = 'Cupons buscados com sucesso!';
			$status = true;
		}else{
			$message = 'Não existe uma pessoa com esse ID';
			$status = false;
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarPostsFavoritos(){
		$parametros = \Request::input();
		$pessoa = Pessoa::find($parametros['id_pessoa']);
		$response = null;

		if($pessoa){
			$response = array();
			foreach ($pessoa->postLikes as $postLike) {
				$response[] = $postLike->postObject;
			}
			foreach ($response as $key => $post) {
				foreach ($post->postLikes as $postLike) {
					$postLike->pessoaObject;
				}
				if($post->id_segmento){
					$response[$key]->segmento = Segmento::find($post->id_segmento);
				}
				if($post->id_empresa){
					$response[$key]->empresa = Empresa::find($post->id_empresa);
					if($response[$key]->empresa){
						$response[$key]->empresa->thumbnail_principal = url('/uploads/empresa/'.$response[$key]->empresa->thumbnail_principal);
					}
				}
				if($response[$key]->data){
					$response[$key]->data = date('d/m/Y', strtotime($post->data));
				}
				if($response[$key]->data_validade){
					$response[$key]->data_validade = date('d/m/Y', strtotime($post->data_validade));
				}
				if($response[$key]->thumbnail_principal){
					$response[$key]->thumbnail_principal = url('/uploads/post/'.$post->thumbnail_principal);
				}
			}
			$message = 'Posts favoritos buscados com sucesso!';
			$status = true;
		}else{
			$message = 'Não existe uma pessoa com esse ID';
			$status = false;
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarPessoa(){
		$parametros = \Request::input();
		$pessoa = Pessoa::find($parametros['id_pessoa']);
		$response = null;

		if($pessoa){
			foreach ($pessoa->segmentos as $pessoaSegmento) {
				$pessoaSegmento->segmentoObject;
			}
			$pessoa->grupoPessoa;
			$pessoa->cidade;
			$pessoa->empresa;
			$response = $pessoa;
			$message = 'Pessoa buscada com sucesso!';
			$status = true;
		}else{
			$message = 'Não existe uma pessoa com esse ID';
			$status = false;
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function cancelarCupom(){
		$params = \Request::input();
		$cupom = Cupom::find($params['id_cupom']);
		$response = null;
		if($cupom){
			if($cupom->cupomPessoa){
				$cupom->cupomPessoa->delete();
				$cupom->status = 'A';
				$cupom->save();
				$message = 'Cupom cancelado com sucesso!';
				$status = true;
			}else{
				$message = 'Não existe uma pessoa vinculada a esse cupom.';
				$status = false;
			}
		}else{
			$message = 'Não existe um cupom com esse ID';
			$status = false;
		}
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarEnderecosEmpresa(){
		$params = \Request::input();
		$empresa = Empresa::find($params['id_empresa']);
		$response = null;
		if($empresa){
			$response = [
				'latitude' => $empresa->latitude,
				'longitude' => $empresa->longitude,
				'filiais' => []
			];
			foreach ($empresa->filiais as $filial) {
				$response['filiais'][] = [
					'latitude' => $filial->latitude,
					'longitude' => $filial->longitude
				];
			}
			$status = true;
			$message = 'Endereços buscados com sucesso.';
		}else{
			$message = 'Não existe uma empresa com esse ID';
			$status = false;
		}
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarMapa(){
		$params = \Request::input();
		$latitude = $params['latitude'];
		$longitude = $params['longitude'];
		$distancia = isset($params['distancia']) ? $params['distancia'] : 50;
		$response = null;

		$empresas = DB::table('empresa')->select('empresa.nome_fantasia', 'empresa.latitude', 'empresa.longitude', DB::raw('111.045 * DEGREES(ACOS(COS(RADIANS('.$latitude.')) * COS(RADIANS(empresa.latitude)) * COS(RADIANS(empresa.longitude) - RADIANS('.$longitude.')) + SIN(RADIANS('.$latitude.')) * SIN(RADIANS(empresa.latitude)))) AS distance_in_km'))->havingRaw('distance_in_km <= '.$distancia)->get();

		$filiais = DB::table('empresa')->select('empresa.nome_fantasia','empresa_filial_endereco.latitude', 'empresa_filial_endereco.longitude', DB::raw('111.045 * DEGREES(ACOS(COS(RADIANS('.$latitude.')) * COS(RADIANS(empresa_filial_endereco.latitude)) * COS(RADIANS(empresa_filial_endereco.longitude) - RADIANS('.$longitude.')) + SIN(RADIANS('.$latitude.')) * SIN(RADIANS(empresa_filial_endereco.latitude)))) AS distance_filial_in_km') )->join('empresa_filial_endereco','empresa.id', '=', 'empresa_filial_endereco.id_empresa')->havingRaw('distance_filial_in_km <= '.$distancia)->get();

		$response = array_merge($empresas, $filiais);

		$status = true;
		$message = 'Empresas buscadas com sucesso.';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function alterarPessoa(){
		$input = \Request::input();

		$nome = (isset($input['nome']) && $input['nome']) ? $input['nome'] : null;
		$telefone = (isset($input['telefone']) && $input['telefone']) ? $input['telefone'] : null;
		$celular = (isset($input['celular']) && $input['celular']) ? $input['celular'] : null;
		$email = (isset($input['email']) && $input['email']) ? $input['email'] : null;
		$data_nascimento = (isset($input['data_nascimento']) && $input['data_nascimento']) ? $input['data_nascimento'] : null;
		$id_cidade = (isset($input['id_cidade']) && $input['id_cidade']) ? $input['id_cidade'] : null;
		$sexo = (isset($input['sexo']) && $input['sexo']) ? $input['sexo'] : null;
		$password = (isset($input['password']) && $input['password']) ? $input['password'] : null;

		$pessoa = Pessoa::find($input['id_pessoa']);
		if($pessoa){
			$user = User::find($pessoa->id_user);
			$pessoa->nome = $nome;
			$pessoa->telefone = $telefone;
			$pessoa->celular = $celular;
			$pessoa->data_nascimento = $data_nascimento;
			$pessoa->id_cidade = $id_cidade;
			$pessoa->sexo = $sexo;
			if($email){
				if(User::where('email', $email)->count() && $email != $user->email){
					return json_encode(array(
						'status' => false,
						'message' => 'Esse e-mail já está em uso'
					));
				}else{
					$pessoa->email = $email;
				}

				$user->email = $email;
			}
			if($password){
				$user->password = bcrypt($password);
			}
			$pessoa->save();
			$user->save();

			return json_encode(array(
				'status' => true,
				'message' => 'Dados alterados com sucesso!'
			));
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não existe uma pessoa com esse ID.'
			));
		}
	}

	public function alterarStatusCupom(Request $request){
		$post = $request->input();
		$cupom = Cupom::find($post['id_cupom']);
		if($post['status'] == 'F' || $post['status'] == 'U' && $cupom->data_validade >= date('Y-m-d')){ // Verifica se está tentando utilizar um cupom vencido
			if($post['status'] == 'F' || $post['status'] == 'U' && $cupom->cupomPessoa){ // Verifica se esta tentando utilizar um cupom sem pessoa
				$cupom->status = $post['status'];
				$cupom->save();
				$status = true;
				$message = 'Status alterado com sucesso.';
			}else{
				$status = false;
				$message = 'Não foi possível alterar o status. Verifique se esse cupom possui uma pessoa ligada a ele.';
			}
		}else{
			$status = false;
			$message = 'Não foi possível alterar o status. Verifique a data de validade do cupom.';
		}


		return json_encode(array(
			'status' => $status,
			'message' => $message
		));
	}

	public function criarUsuarioAuxiliar(){
		$post = \Request::input();
		if(!isset($post['password']) || !$post['password']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo senha é obrigatório'
			));
		}
		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório'
			));
		}
		if(!isset($post['email']) || !$post['email']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo e-mail é obrigatório'
			));
		}
		if(User::where('email', $post['email'])->count()){
			return json_encode(array(
				'status' => false,
				'message' => 'Já existe um usuário com esse e-mail.'
			));
		}

		$condominoCriador = Condominos::select('condomino.*')->join('sis_users','condomino.id', '=', 'sis_users.id_condomino')->where('sis_users.id', $post['id_criador'])->first();

		$condomino = new Condominos();
		$condomino->nome_completo = $post['nome'];
		$condomino->email = $post['email'];
		$condomino->id_condominio_unidade = $condominoCriador->id_condominio_unidade;
		$condomino->save();

		$user = new User();
		$user->password = bcrypt($post['password']);
		$user->email = $post['email'];
		$user->first_name = $post['nome'];
		$user->id_condomino = $condomino->id;
		$user->id_criador = $post['id_criador'];
		$user->save();

		$userSentinel = Sentinel::findUserById($user->id);

		$activation = Activation::create($userSentinel);
		Activation::complete($userSentinel, $activation->code);

		$role = Sentinel::findRoleById(4);
		$role->users()->attach($userSentinel);

		if(isset($post['permissions'])){
			$permissions = [];
			foreach ($post['permissions'] as $module_name => $status) {
				$permissions[$module_name.'.view'] = $status;
				$permissions[$module_name.'.create'] = $status;
			}
			$userSentinel->permissions = $permissions;
			$userSentinel->save();
		}

		return json_encode(array(
			'status' => true,
			'message' => 'Usuário criado com sucesso!'
		));
	}

	public function editarUsuarioAuxiliar(){
		$post = \Request::input();
		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório'
			));
		}
		if(!isset($post['email']) || !$post['email']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo e-mail é obrigatório'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Usuário é obrigatório'
			));
		}
		$userEmail = User::where('email', $post['email'])->first();
		if($userEmail && ($userEmail->id != $post['id_user'])){
			return json_encode(array(
				'status' => false,
				'message' => 'Já existe um usuário com esse e-mail.'
			));
		}
		$user = User::find($post['id_user']);
		if(!$user){
			return json_encode(array(
				'status' => false,
				'message' => 'Não existe um usuário com esse ID.'
			));
		}

		if(isset($post['password']) && $post['password']){
			if(strlen($post['password']) >= 6){
				$user->password = bcrypt($post['password']);
			}else{
				return json_encode(array(
					'status' => false,
					'message' => 'A senha deve conter no mínimo 6 caracteres.'
				));
			}
		}

		$user->email = $post['email'];
		$user->first_name = $post['nome'];
		$user->save();

		$condomino = $user->condomino;
		$condomino->nome_completo = $post['nome'];
		$condomino->email = $post['email'];
		$condomino->save();

		$userSentinel = Sentinel::findUserById($user->id);

		if(isset($post['permissions'])){
			$permissions = [];
			foreach ($post['permissions'] as $module_name => $status) {
				$permissions[$module_name.'.view'] = $status;
				$permissions[$module_name.'.create'] = $status;
			}
			$userSentinel->permissions = $permissions;
			$userSentinel->save();
		}

		return json_encode(array(
			'status' => true,
			'message' => 'Usuário editado com sucesso!'
		));
	}

	public function salvarEnquete(){
		$post = \Request::input();

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório'
			));
		}
		if(!isset($post['data_limite']) || !$post['data_limite']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo data limite é obrigatório'
			));
		}
		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_condominio é obrigatório'
			));
		}

		if(!isset($post['alternativas']) || !count($post['alternativas'])){
			return json_encode(array(
				'status' => false,
				'message' => 'Você precisa cadastrar alternativas para a enquete.'
			));
		}

		$enquete = new Enquete();
		$enquete->nome = $post['nome'];
		$enquete->descricao = (isset($post['descricao'])) ? $post['descricao'] : '';
		$enquete->data_criacao = date('Y-m-d H:i:s');
		$enquete->data_finalizacao = $post['data_limite'];
		$enquete->id_condominio = $post['id_condominio'];
		$enquete->save();

		$idSindico = CondominioService::buscarSindicoCondominio($post['id_condominio']);
		CondominioService::notificarCondominio($idSindico, 'S', 'O Síndico criou uma nova enquete.', $post['nome'], $post['id_condominio'], 'enquete', $enquete->id);

		foreach ($post['alternativas'] as $alternativa) {
			$alternativaModel = new EnqueteAlternativa();
			$alternativaModel->id_enquete = $enquete->id;
			$alternativaModel->descricao = $alternativa;
			$alternativaModel->save();
		}


		return json_encode(array(
			'status' => true,
			'message' => 'Enquete criada com sucesso!'
		));
	}

	public function buscarEnquetes(){
		$post = \Request::input();
		$limit = isset($post['limit']) ? $post['limit'] : 10;
		$offset = isset($post['offset']) ? $post['offset'] : 0;
		$countFinalizadas = 0;
		$response = null;
		if(isset($post['id_condominio']) && $post['id_condominio']){
			$enquetesAbertas = [];
			$enquetesFinalizadas = [];
			$enquetes = Enquete::where('id_condominio', $post['id_condominio'])->orderBy('data_criacao', 'DESC')->get();

			foreach ($enquetes as $enquete) {
				$totalVotos = EnqueteAlternativaUsers::join('enquete_alternativa', 'enquete_alternativa_users.id_enquete_alternativa', '=', 'enquete_alternativa.id')->where('enquete_alternativa.id_enquete', $enquete->id)->count();
				foreach ($enquete->alternativas as $alternativa) {
					$alternativa->nr_votos = count($alternativa->votos);
					if($totalVotos)
					$alternativa->porcentagem = ($alternativa->nr_votos / $totalVotos) * 100;
					else {
						$alternativa->porcentagem = 0;
					}
				}
				if($enquete->data_finalizacao < date('Y-m-d H:i:s')){
					$enquete->finalizada = true;
					if($countFinalizadas < $limit && $countFinalizadas >= $offset){
						$enquetesFinalizadas[] = $enquete;
						$countFinalizadas++;
					}
				}else{
					$enquete->finalizada = false;
					$enquetesAbertas[] = $enquete;
				}
				$enquete->ja_votou = false;
				if(isset($post['id_user'])){
					$votoUsuario = EnqueteAlternativaUsers::join('enquete_alternativa', 'enquete_alternativa_users.id_enquete_alternativa', '=', 'enquete_alternativa.id')->where('id_user_principal', $post['id_user'])->where('enquete_alternativa.id_enquete', $enquete->id)->count();
					if($votoUsuario){
						$enquete->ja_votou = true;
					}
				}

			}
			$status = true;
			$message = 'Enquetes buscadas com sucesso!';
			$response = array(
				'enquetes_abertas' => $enquetesAbertas,
				'enquetes_finalizadas' => $enquetesFinalizadas
			);
		}else{
			$status = false;
			$message = 'ID do condomínio é obrigatório.';
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarEnquete(){
		$post = \Request::input();
		$response = null;
		if(isset($post['id_enquete']) && $post['id_enquete']){
			$enquete = Enquete::find($post['id_enquete']);
			if($enquete){
				$totalVotos = EnqueteAlternativaUsers::join('enquete_alternativa', 'enquete_alternativa_users.id_enquete_alternativa', '=', 'enquete_alternativa.id')->where('enquete_alternativa.id_enquete', $enquete->id)->count();
				foreach ($enquete->alternativas as $alternativa) {
					$alternativa->nr_votos = count($alternativa->votos);
					if($totalVotos)
					$alternativa->porcentagem = ($alternativa->nr_votos / $totalVotos) * 100;
					else {
						$alternativa->porcentagem = 0;
					}

				}
				if($enquete->data_finalizacao < date('Y-m-d H:i:s')){
					$enquete->finalizada = true;
				}else{
					$enquete->finalizada = false;
				}

				$enquete->ja_votou = false;
				if(isset($post['id_user'])){
					$votoUsuario = EnqueteAlternativaUsers::join('enquete_alternativa', 'enquete_alternativa_users.id_enquete_alternativa', '=', 'enquete_alternativa.id')->where('id_user_principal', $post['id_user'])->where('enquete_alternativa.id_enquete', $enquete->id)->count();
					if($votoUsuario){
						$enquete->ja_votou = true;
					}
				}
				$status = true;
				$message = 'Enquete buscada com sucesso!';
				$response = $enquete;
			}else{
				$status = false;
				$message = 'Enquete com esse ID não foi encontrada.';
			}
		}else{
			$status = false;
			$message = 'ID da enquete é obrigatório.';
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function votarEnquete(){
		$post = \Request::input();
		$response = null;
		$enqueteAlternativaUsers = new EnqueteAlternativaUsers();
		$enqueteAlternativaUsers->id_user_principal = $post['id_user'];
		$enqueteAlternativaUsers->id_enquete_alternativa = $post['id_alternativa'];
		$enqueteAlternativaUsers->data = date('Y-m-d H:i:s');
		$enqueteAlternativaUsers->save();
		$status = true;
		$message = 'Voto salvo com sucesso!';
		$response = $enqueteAlternativaUsers;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function criarQuestionamento(){
		$post = \Request::input();
		$response = null;
		if(!isset($post['mensagem']) || !$post['mensagem']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo mensagem é obrigatório.'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo usuário é obrigatório.'
			));
		}
		if(!isset($post['id_assunto']) || !$post['id_assunto']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo assunto é obrigatório.'
			));
		}
		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo condomínio é obrigatório.'
			));
		}
		if(!isset($post['tipo']) || !$post['tipo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tipo é obrigatório.'
			));
		}

		$questionamento = new Questionamento();
		$questionamento->descricao = $post['mensagem'];
		$questionamento->id_user_remetente = $post['id_user'];
		$questionamento->id_questionamento_assunto = $post['id_assunto'];
		$questionamento->tipo = $post['tipo'];
		$questionamento->status = 'P';
		$idSindico = CondominioService::buscarSindicoCondominio($post['id_condominio']);
		$questionamento->id_user_destinatario = $idSindico;
		$questionamento->data_criacao = date('Y-m-d H:i:s');
		if(isset($post['data_finalizacao']) && $post['data_finalizacao']){
			$questionamento->data_finalizacao = $post['data_finalizacao'];
		}
		if(isset($post['imagem']) && $post['imagem']){
			$questionamento->thumbnail_principal = $post['imagem'];
			$questionamento->thumbnail_app = 'thumb_'.$post['imagem'];
		}
		$questionamento->save();
		$status = true;
		$message = 'Questionamento criado com sucesso!';
		$response = $questionamento;

		//CondominioService::notificarUsuario($post['id_user'], 'V', 'Você tem um novo questionamento.', $questionamento->descricao, $idSindico, 'questionamento', $questionamento->id);
		$userSindico = User::find($idSindico);
		$onesignal = [
			0 => $userSindico->udid
		];
		CondominioService::sendMessage($onesignal, $questionamento->descricao, 'Você tem um novo questionamento.', 'questionamento', $questionamento->id);

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function responderQuestionamento(){
		$post = \Request::input();
		$response = null;
		if(!isset($post['descricao']) || !$post['descricao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo descricao é obrigatório.'
			));
		}
		if(!isset($post['id_user_sindico']) || !$post['id_user_sindico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user_sindico é obrigatório.'
			));
		}
		if(!isset($post['id_questionamento']) || !$post['id_questionamento']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_questionamento é obrigatório.'
			));
		}
		if(!isset($post['status']) || !$post['status']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo status é obrigatório.'
			));
		}

		$questionamento = Questionamento::find($post['id_questionamento']);
		if($questionamento){


			$questionamento->status = $post['status'];
			$questionamento->save();


			$questionamentoResposta = new QuestionamentoResposta();
			$questionamentoResposta->descricao = $post['descricao'];
			$questionamentoResposta->id_user_sindico = $post['id_user_sindico'];
			$questionamentoResposta->id_questionamento = $post['id_questionamento'];
			$questionamentoResposta->data = date('Y-m-d H:i:s');
			$questionamentoResposta->save();
			$status = true;
			$message = 'Questionamento respondido com sucesso!';
			$response = $questionamentoResposta;

			CondominioService::notificarUsuario($post['id_user_sindico'], 'S', 'O síndico respondeu seu questionamento.', $questionamento->descricao, $questionamento->id_user_remetente, 'questionamentoResposta', $questionamento->id);

			return json_encode(array(
				'status' => $status,
				'message' => $message,
				'response' => $response
			));
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um questionamento com esse ID.'
			));
		}
	}

	public function responderRecado(){
		$post = \Request::input();
		$response = null;
		if(!isset($post['descricao']) || !$post['descricao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo descricao é obrigatório.'
			));
		}
		if(!isset($post['id_user_remetente']) || !$post['id_user_remetente']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user_remetente é obrigatório.'
			));
		}
		if(!isset($post['id_recado']) || !$post['id_recado']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_recado é obrigatório.'
			));
		}

		$recado = Recado::find($post['id_recado']);
		if($recado){


			$recadoResposta = new RecadoResposta();
			$recadoResposta->descricao = $post['descricao'];
			$recadoResposta->id_user_remetente = $post['id_user_remetente'];
			$recadoResposta->id_recado = $post['id_recado'];
			$recadoResposta->data = date('Y-m-d H:i:s');
			if(isset($post['atendido']) && $post['atendido']){
				$recado->id_user_atendido = $post['id_user_remetente'];
				$recado->save();
				$recadoResposta->atendido = 1;
			}
			$recadoResposta->save();

			$status = true;
			$message = 'Recado respondido com sucesso!';
			$response = $recadoResposta;

			$user = User::find($post['id_user_remetente']);
			$title = $user->first_name.' '.$user->last_name.' respondeu seu recado.';

			/* Se o usuário responder o próprio recado, notifica todos que responderam o recado */
			if($post['id_user_remetente'] == $recado->id_user_remetente){
				$respostas = RecadoResposta::where('id_recado', $recado->id)->where('id_user_remetente', '!=', $recado->id_user_remetente)->groupBy('id_user_remetente')->get();
				foreach ($respostas as $resposta) {
					CondominioService::notificarUsuario($post['id_user_remetente'], 'V', 'Há novas respostas no recado que você respondeu.', $recado->descricao, $resposta->id_user_remetente, 'recadoResposta', $recado->id);
				}
			}else{ // Senão responde apenas o criador do recado.
				CondominioService::notificarUsuario($post['id_user_remetente'], 'V', $title, $recado->descricao, $recado->id_user_remetente, 'recadoResposta', $recado->id);
			}

			return json_encode(array(
				'status' => $status,
				'message' => $message,
				'response' => $response
			));
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um recado com esse ID.'
			));
		}
	}

	public function editarQuestionamento(){
		$post = \Request::input();
		$response = null;
		if(!isset($post['id_questionamento']) || !$post['id_questionamento']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Questionamento é obrigatório.'
			));
		}
		if(!isset($post['mensagem']) || !$post['mensagem']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo mensagem é obrigatório.'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo usuário é obrigatório.'
			));
		}
		if(!isset($post['id_assunto']) || !$post['id_assunto']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo assunto é obrigatório.'
			));
		}
		if(!isset($post['tipo']) || !$post['tipo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tipo é obrigatório.'
			));
		}

		if(!isset($post['status']) || !$post['status']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo status é obrigatório.'
			));
		}

		$questionamento = Questionamento::find($post['id_questionamento']);
		if($questionamento){
			$questionamento->descricao = $post['mensagem'];
			$questionamento->id_user_remetente = $post['id_user'];
			$questionamento->id_questionamento_assunto = $post['id_assunto'];
			$questionamento->tipo = $post['tipo'];
			$questionamento->status = $post['status'];
			$questionamento->data_finalizacao = $post['data_finalizacao'];
			if(isset($post['imagem']) && $post['imagem']){
				$questionamento->thumbnail_principal = $post['imagem'];
				$questionamento->thumbnail_app = 'thumb_'.$post['imagem'];
			}
			if(isset($post['data_finalizacao']) && $post['data_finalizacao']){
				$questionamento->data_finalizacao = $post['data_finalizacao'];
			}
			$questionamento->save();
			$status = true;
			$message = 'Questionamento editado com sucesso!';
			$response = $questionamento;
		}else{
			$status = false;
			$message = 'Não foi encontrado nenhum questionamento com esse ID.';
		}


		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarAssuntosQuestionamentos(){
		$response = QuestionamentoAssunto::get();
		$status = true;
		$message = 'Registros buscados com sucesso!';
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarTiposEspacoComum(){
		$params = \Request::input();
		$query = EspacoComumTipo::select('espaco_comum_tipo.*');
		if(isset($params['id_espaco_comum_tipo'])){
			$query->where('id', $params['id_espaco_comum_tipo']);
		}
		$response = $query->get();
		$status = true;
		$message = 'Registros buscados com sucesso!';
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarModelosEspacoComum(){
		$params = \Request::input();
		$query = EspacoComumModelo::select('espaco_comum_modelo.*');
		if(isset($params['id_espaco_comum_modelo'])){
			$query->where('id', $params['id_espaco_comum_modelo']);
		}
		if(isset($params['id_espaco_comum_tipo'])){
			$query->where('id_espaco_comum_tipo', $params['id_espaco_comum_tipo']);
		}
		$response = $query->get();
		foreach ($response as $espacoComumModelo) {
			$espacoComumModelo->items;
			$espacoComumModelo->horarios;
		}
		$status = true;
		$message = 'Registros buscados com sucesso!';
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarTiposAnimal(){
		$response = TipoAnimal::get();
		$status = true;
		$message = 'Registros buscados com sucesso!';
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response->toArray()
		));
	}

	public function criarAnimal(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['raca']) || !$post['raca']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo raça é obrigatório.'
			));
		}
		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo usuário é obrigatório.'
			));
		}
		if(!isset($post['id_tipo_animal']) || !$post['id_tipo_animal']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo espécie é obrigatório.'
			));
		}

		$animal = new Animal();
		$animal->raca = $post['raca'];
		$animal->nome = $post['nome'];
		$animal->id_condominio_unidade = \App\Services\CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
		$animal->id_tipo_animal = $post['id_tipo_animal'];
		$animal->save();
		$status = true;
		$message = 'Animal salvo com sucesso!';
		$response = $animal;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function editarAnimal(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_animal']) || !$post['id_animal']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID do animal é obrigatório.'
			));
		}
		if(!isset($post['raca']) || !$post['raca']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo raça é obrigatório.'
			));
		}
		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo usuário é obrigatório.'
			));
		}
		if(!isset($post['id_tipo_animal']) || !$post['id_tipo_animal']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo espécie é obrigatório.'
			));
		}

		$animal = Animal::find($post['id_animal']);
		$animal->raca = $post['raca'];
		$animal->nome = $post['nome'];
		$animal->id_condominio_unidade = \App\Services\CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
		$animal->id_tipo_animal = $post['id_tipo_animal'];
		$animal->save();
		$status = true;
		$message = 'Animal editado com sucesso!';
		$response = $animal;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function criarVeiculo(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['placa']) || !$post['placa']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo placa é obrigatório.'
			));
		}
		if(!isset($post['modelo']) || !$post['modelo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo modelo é obrigatório.'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}
		if(!isset($post['cor']) || !$post['cor']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo cor é obrigatório.'
			));
		}

		$veiculo = new Veiculo();
		$veiculo->placa = $post['placa'];
		$veiculo->cor = $post['cor'];
		$veiculo->id_condominio_unidade = \App\Services\CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
		$veiculo->modelo = $post['modelo'];
		$veiculo->save();
		$status = true;
		$message = 'Veículo salvo com sucesso!';
		$response = $veiculo;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function editarVeiculo(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_veiculo']) || !$post['id_veiculo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID do veículo é obrigatório.'
			));
		}
		if(!isset($post['placa']) || !$post['placa']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo placa é obrigatório.'
			));
		}
		if(!isset($post['modelo']) || !$post['modelo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo modelo é obrigatório.'
			));
		}
		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}
		if(!isset($post['cor']) || !$post['cor']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo cor é obrigatório.'
			));
		}

		$veiculo = Veiculo::find($post['id_veiculo']);
		$veiculo->placa = $post['placa'];
		$veiculo->cor = $post['cor'];
		$veiculo->id_condominio_unidade = \App\Services\CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
		$veiculo->modelo = $post['modelo'];
		$veiculo->save();
		$status = true;
		$message = 'Veículo editado com sucesso!';
		$response = $veiculo;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarVeiculos(){
		$post = \Request::input();
		$response = null;
		if(isset($post['id_veiculo'])){
			$veiculo = Veiculo::find($post['id_veiculo']);
			if($veiculo){
				$response = $veiculo;
				$status = true;
				$message = 'Registro buscado com sucesso!';
			}else{
				$status = false;
				$message = 'Não foi encontrado um veículo com esse ID.';
			}
		}else{
			if(isset($post['id_user']) && $post['id_user']){
				if(User::where('id', $post['id_user'])->count()){
					$id_condominio_unidade = CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
					$response = Veiculo::where('id_condominio_unidade', $id_condominio_unidade)->get();
					$status = true;
					$message = 'Registros buscados com sucesso!';
				}else{
					$status = false;
					$message = 'Não foi encontrado um usuário com esse ID.';
				}
			}else{
				$status = false;
				$message = 'O ID do usuário é obrigatório.';
			}

		}
		return response()->json(array('status' => $status, 'message' => $message, 'response' => $response));
	}


	public function buscarAnimais(){
		$post = \Request::input();
		$response = null;
		if(isset($post['id_animal'])){
			$animal = Animal::find($post['id_animal']);
			if($animal){
				$response = $animal;
				$status = true;
				$message = 'Registro buscado com sucesso!';
			}else{
				$status = false;
				$message = 'Não foi encontrado um veículo com esse ID.';
			}
		}else{
			if(isset($post['id_user']) && $post['id_user']){
				if(User::where('id', $post['id_user'])->count()){
					$id_condominio_unidade = CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
					$response = Animal::where('id_condominio_unidade', $id_condominio_unidade)->get();
					$status = true;
					$message = 'Registros buscados com sucesso!';
				}else{
					$status = false;
					$message = 'Não foi encontrado um usuário com esse ID.';
				}
			}else{
				$status = false;
				$message = 'O ID do usuário é obrigatório.';
			}
		}
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function deletarVeiculo(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_veiculo']) || !$post['id_veiculo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Veículo é obrigatório.'
			));
		}

		$veiculo = Veiculo::find($post['id_veiculo']);
		if($veiculo){
			$veiculo->delete();
			$status = true;
			$message = 'Veículo removido com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um veículo com esse ID.'
			));
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function deletarQuestionamento(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_questionamento']) || !$post['id_questionamento']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Questionamento é obrigatório.'
			));
		}

		$questionamento = Questionamento::find($post['id_questionamento']);
		if($questionamento){
			@unlink('uploads/questionamento/'.$questionamento->thumbnail_principal);
			$questionamento->delete();
			$status = true;
			$message = 'Questionamento removido com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um questionamento com esse ID.'
			));
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function deletarAnimal(){
		$post = \Request::input();
		$response = null;
		if(!isset($post['id_animal']) || !$post['id_animal']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Animal é obrigatório.'
			));
		}
		$animal = Animal::find($post['id_animal']);
		if($animal){
			$animal->delete();
			$status = true;
			$message = 'Animal removido com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um animal com esse ID.'
			));
		}
		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function deletarUsuario(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Usuário é obrigatório.'
			));
		}

		$user = User::find($post['id_user']);
		if($user){
			if($user->condomino){
				$user->condomino->delete();
			}
			$user->delete();
			$status = true;
			$message = 'Usuário removido com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um usuário com esse ID.'
			));
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarUsuariosAuxiliares(){
		$post = \Request::input();
		$response = null;

		if(isset($post['id_user'])){
			$user = User::find($post['id_user']);
			$user->condomino;
			$user->permissions = str_replace('.', '_',$user->permissions);
			$response = $user;
			$message = 'Usuário buscado com sucesso!';
			$status = true;
		}else{
			if(!isset($post['id_criador']) || !$post['id_criador']){
				return json_encode(array(
					'status' => false,
					'message' => 'O campo ID Criador é obrigatório.'
				));
			}
			$usuarios = User::where('sis_users.id_criador',$post['id_criador'])->get();
			foreach ($usuarios as $usuario) {
				$usuario->condomino;
				$usuario->permissions = str_replace('.', '_',$usuario->permissions);
			}
			$response = $usuarios;
			$status = true;
			$message = 'Usuários buscados com sucesso!';
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function uploadImagem(Request $request){

		$post = \Request::input();
		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
			'status' => false,
			'message' => 'o id_condominio é obrigatório'
			));
		}

		if($request->hasFile('file')) {
			//upload an image to the /img/tmp directory and return the filepath.
			$file = $request->file('file');
			$tmpFilePath = 'uploads/'.$request->input('tipo').'/'.$request->input('id_condominio').'/';
			$tmpFileName = time() . '-' . $file->getClientOriginalName();
			$file = $file->move(public_path() .'/'. $tmpFilePath, $tmpFileName);
			$path = $tmpFilePath . $tmpFileName;

			$img = \Image::make($tmpFilePath.$tmpFileName);
			$tmpThumbName = 'thumb_'.$tmpFileName;
			if($img->resize($img->width()/5, $img->height()/5)->save($tmpFilePath.$tmpThumbName)){
				$pathThumb = '/'.$tmpFilePath.$tmpThumbName;
				return response()->json(array('path'=> $path, 'file_name'=>$tmpFileName, 'path_thumb' => $pathThumb, 'file_name_thumb' => $tmpThumbName), 200);
			}else{
				return response()->json(array('status'=>false,'message' => 'Não foi possível alterar o tamanho da imagem.'), 200);
			}
		} else {
			return response()->json(false, 200);
		}
	}

	public function criarAssembleia(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['titulo']) || !$post['titulo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo título é obrigatório.'
			));
		}
		if(!isset($post['data_primeira_chamada']) || !$post['data_primeira_chamada']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo data da primeira chamada é obrigatório.'
			));
		}
		if(!isset($post['data_segunda_chamada']) || !$post['data_segunda_chamada']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo data da segunda chamada é obrigatório.'
			));
		}
		if(!isset($post['local']) || !$post['local']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo local é obrigatório.'
			));
		}
		if(!isset($post['descricao']) || !$post['descricao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo descrição é obrigatório.'
			));
		}
		if(!isset($post['torres']) || !count($post['torres'])){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo torres é obrigatório.'
			));
		}
		if(!isset($post['questionamentos']) || !count($post['questionamentos'])){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo questionamentos é obrigatório.'
			));
		}

		$assembleia = new Assembleia();
		$assembleia->titulo = $post['titulo'];
		$assembleia->data_primeira_chamada = $post['data_primeira_chamada'];
		$assembleia->data_segunda_chamada = $post['data_segunda_chamada'];
		$assembleia->local = $post['local'];
		$assembleia->descricao = $post['descricao'];
		$assembleia->save();

		foreach ($post['torres'] as $id_torre) {
			$assembleiaTorre = new AssembleiaCondominioTorre();
			$assembleiaTorre->id_assembleia = $assembleia->id;
			$assembleiaTorre->id_condominio_torre = $id_torre;
			$assembleiaTorre->save();
		}

		foreach ($post['questionamentos'] as $id_questionamento) {
			$assembleiaQuestionamento = new AssembleiaQuestionamento();
			$assembleiaQuestionamento->id_assembleia = $assembleia->id;
			$assembleiaQuestionamento->id_questionamento = $id_questionamento;
			$assembleiaQuestionamento->save();
		}

		$status = true;
		$message = 'Assembléia criada com sucesso!';
		$response = $assembleia;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function criarModeloEspacoComum(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}
		if(!isset($post['id_espaco_comum_tipo']) || !$post['id_espaco_comum_tipo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tipo do espaço comum é obrigatório.'
			));
		}
		if(!isset($post['hora_inicio_utilizacao']) || !$post['hora_inicio_utilizacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo hora de inicio de utilização é obrigatório.'
			));
		}
		if(!isset($post['hora_fim_utilizacao']) || !$post['hora_fim_utilizacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo hora final de utilização é obrigatório.'
			));
		}
		if(!isset($post['tempo_utilizacao']) || !$post['tempo_utilizacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tempo de utilização é obrigatório.'
			));
		}
		if(!isset($post['items']) || !count($post['items'])){
			return json_encode(array(
				'status' => false,
				'message' => 'Os items são obrigatório.'
			));
		}


		$espacoComumModelo = new EspacoComumModelo();
		$espacoComumModelo->nome = $post['nome'];
		$espacoComumModelo->hora_inicio_utilizacao = $post['hora_inicio_utilizacao'];
		$espacoComumModelo->hora_fim_utilizacao = $post['hora_fim_utilizacao'];
		$espacoComumModelo->tempo_utilizacao = $post['tempo_utilizacao'];
		$espacoComumModelo->id_espaco_comum_tipo = $post['id_espaco_comum_tipo'];
		$espacoComumModelo->save();

		foreach ($post['items'] as $item) {
			$espacoComumItensModelo = new EspacoComumItensModelo();
			$espacoComumItensModelo->id_espaco_comum_modelo = $espacoComumModelo->id;
			$espacoComumItensModelo->chave = $item['chave'];
			$espacoComumItensModelo->valor = $item['valor'];
			$espacoComumItensModelo->save();
		}

		$status = true;
		$message = 'Modelo criado com sucesso!';
		$response = $espacoComumModelo;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function criarEspacoComum(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}
		if(!isset($post['id_espaco_comum_tipo']) || !$post['id_espaco_comum_tipo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tipo do espaço comum é obrigatório.'
			));
		}
		if(!isset($post['id_espaco_comum_modelo']) || !$post['id_espaco_comum_modelo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Modelo do espaço comum é obrigatório.'
			));
		}


		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo condomínio é obrigatório.'
			));
		}

		if(!isset($post['capacidade']) || !$post['capacidade']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo capacidade é obrigatório.'
			));
		}

		// sem valor é igual a 0
		if(!isset($post['valor_taxa_uso']) || !$post['valor_taxa_uso']){
			$post['valor_taxa_uso'] = 0;
		}
		if(!isset($post['reserva_aprovada'])){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo de preciso aprovar a reserva é obrigatório.'
			));
		}

		switch ($post['id_espaco_comum_tipo']) {
			case 1:
             $thumb = 'uploads/app/salaodefestas.jpg';
             break;
         // quadra de futebol
         case 3:
             $thumb = 'uploads/app/futebol.jpg';
             break;

         // quadra de tenis
         case 4:
             $thumb = 'uploads/app/img1.png';
             break;

             // academia
         case 5:
             $thumb = 'uploads/app/academia.jpg';
             break;

         default:
             $thumb = 'uploads/app/img3.png';
             break;
		}

		$modeloEspacoComum = EspacoComumModelo::where('espaco_comum_modelo.id',$post['id_espaco_comum_modelo'])->first();


		$espacoComum = new EspacoComum();
		$espacoComum->nome = $post['nome'];
		$espacoComum->thumbnail_principal = $thumb;
	//	$espacoComum->hora_inicio_utilizacao = $post['hora_inicio_utilizacao'];
	//	$espacoComum->hora_fim_utilizacao = $post['hora_fim_utilizacao'];
	//	$espacoComum->tempo_utilizacao = $post['tempo_utilizacao'];
		$espacoComum->id_espaco_comum_tipo = $post['id_espaco_comum_tipo'];
		$espacoComum->capacidade = $post['capacidade'];
		$espacoComum->valor_taxa_uso = $post['valor_taxa_uso'];
		$espacoComum->reserva_aprovada = $post['reserva_aprovada'];
		$espacoComum->id_condominio = $post['id_condominio'];
		$espacoComum->convidados = (isset($post['convidados'])) ? $post['convidados'] : 0;
		$espacoComum->save();

		foreach ($modeloEspacoComum->horarios as $horario) {
			$espacoComumHorario = new EspacoComumHorario();
			$espacoComumHorario->id_espaco_comum = $espacoComum->id;
			$espacoComumHorario->dia = $horario->dia;
			$espacoComumHorario->hora_inicial = $horario->hora_inicial;
			$espacoComumHorario->hora_final = $horario->hora_final;
			$espacoComumHorario->save();
		}

		$status = true;
		$message = 'Espaço comum criado com sucesso!';
		$response = $espacoComum;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}




	public function editarEspacoComum(){

		$post = \Request::input();
		$response = null;

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}


		if(!isset($post['id_espaco_comum']) || !$post['id_espaco_comum']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_espaco_comum é obrigatório.'
			));
		}

		if(!isset($post['capacidade']) || !$post['capacidade']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo capacidade é obrigatório.'
			));
		}
		// sem valor é igual a 0
		if(!isset($post['valor_taxa_uso']) || !$post['valor_taxa_uso']){
			$post['valor_taxa_uso'] = 0;
		}
		if(!isset($post['reserva_aprovada'])){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo de preciso aprovar a reserva é obrigatório.'
			));
		}

		$espacoComum = EspacoComum::find($post['id_espaco_comum']);
		$espacoComum->nome = $post['nome'];
		$espacoComum->capacidade = $post['capacidade'];
		$espacoComum->valor_taxa_uso = $post['valor_taxa_uso'];
		$espacoComum->reserva_aprovada = $post['reserva_aprovada'];
		$espacoComum->save();

		$status = true;
		$message = 'Espaço comum editado com sucesso!';
		$response = $espacoComum;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));


	}

	public function deletarEspacoComum(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_espaco_comum']) || !$post['id_espaco_comum']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_espaco_comum obrigatório.'
			));
		}

		$espacoComum = EspacoComum::find($post['id_espaco_comum']);
		if($espacoComum){
			$espacoComum->delete();
			$status = true;
			$message = 'Espaço Comum removido com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um espaco comum com esse ID.'
			));
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function deletarUnidade(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_unidade']) || !$post['id_unidade']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_unidade obrigatório.'
			));
		}

		$unidade = CondominioUnidade::find($post['id_unidade']);
		if($unidade){
			$unidade->delete();
			$status = true;
			$message = 'Unidade removida com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado uma unidade com esse ID.'
			));
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}


	// criar uma nova reserva para um espaco comum
	public function criarReservaEspacoComum(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_espaco_comum']) || !$post['id_espaco_comum']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Id do espaço comum é obrigatório.'
			));
		}

		if(!isset($post['id_user_responsavel']) || !$post['id_user_responsavel']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user_responsavel é obrigatório.'
			));
		}

		if(!isset($post['id_espaco_comum_horario']) || !$post['id_espaco_comum_horario']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo horário é obrigatório.'
			));
		}

		if(!isset($post['data']) || !$post['data']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo data é obrigatório.'
			));
		}

		if(Reserva::where('id_espaco_comum', $post['id_espaco_comum'])->where('data', $post['data'])->where('id_espaco_comum_horario', $post['id_espaco_comum_horario'])->count()){
			return json_encode(array(
				'status' => false,
				'message' => 'Já existe uma reserva nesse horário.'
			));
		}

		$espacoComum = EspacoComum::find($post['id_espaco_comum']);
		$userResponsavel = Sentinel::findUserById($post['id_user_responsavel']);
		if($espacoComum->reserva_aprovada && !$userResponsavel->inRole('sindico')){
			$status = 'P';
		}else{
			$status = 'A';
		}

		$idCondominioUnidade = CondominioService::buscarCondominioUnidadeAtual($post['id_user_responsavel']);

		$reserva = new Reserva();
		$reserva->id_espaco_comum = $post['id_espaco_comum'];
		$reserva->id_condominio_unidade = $idCondominioUnidade;
		$reserva->id_user_responsavel = $post['id_user_responsavel'];
		$reserva->id_espaco_comum_horario = $post['id_espaco_comum_horario'];
		$reserva->data = $post['data'];
		$reserva->status = $status;
		if(isset($post['anexo']) && $post['anexo']){
			$reserva->anexo = $post['anexo'];
		}
		$reserva->save();

		$idCondominio = CondominioService::buscarCondominioAtual($post['id_user_responsavel']);
		$idSindico = CondominioService::buscarSindicoCondominio($idCondominio);
		if($espacoComum->reserva_aprovada){
			CondominioService::notificarUsuario($post['id_user_responsavel'], 'V', 'Há uma nova reserva a ser aprovada.', $espacoComum->nome, $idSindico, 'aprovarReserva', $reserva->id);
		}

		if(isset($post['convidados'])){
			foreach ($post['convidados'] as $convidado) {
				$novoConvidado = new Convidado();
				$novoConvidado->nome = $convidado['nome'];
				$novoConvidado->documento = $convidado['documento'];
				$novoConvidado->save();

				$reservaConvidado = new ReservaConvidado();
				$reservaConvidado->id_convidado = $novoConvidado->id;
				$reservaConvidado->id_reserva = $reserva->id;
				$reservaConvidado->save();
			}
		}

		$status = true;
		$message = 'Reserva criada com sucesso!';
		$response = $reserva;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarHorariosDisponiveis(Request $request){
		$post = $request->input();
		$message = 'Horários buscados com sucesso!';
		$status = true;
		$response = [];
		if($post['data'] >= date('Y-m-d')){
			$espacoComum = EspacoComum::find($post['id_espaco_comum']);
			foreach ($espacoComum->horarios as $horario) {
				if($horario->dia == (date('w', strtotime($post['data'])) + 1) && ($post['data'] >= date('Y-m-d') || $post['data'] == date('Y-m-d') && $horario->hora_inicial >= date('H:i:s')) ){
					$reservado = Reserva::where('data', $post['data'])->where('id_espaco_comum_horario', $horario->id)->where('status', '!=', 'R')->count();
					if(!$reservado){
						$response[] = $horario;
					}
				}
			}
		}else{
			$status = false;
			$message = 'A data deve ser posterior à data atual.';
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}


	public function mudarConfiguracaoNotificacaoUsuario(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}

		if(!isset($post['tipo_notificacao']) || !$post['tipo_notificacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tipo_notificacao é obrigatório.'
			));
		}

		if(!isset($post['ativo'])){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ativo é obrigatório.'
			));
		}


		$query = ConfiguracaoNotificacao::select('configuracao_notificacao.*');
		$query->where('id_user', $post['id_user']);
		$query->where('chave', $post['tipo_notificacao']);
		$notificacoes = $query->first();


		$notificacoes->ativo = $post['ativo'];
		$notificacoes->save();

		$status = true;
		$message = 'Notificação alterada com sucesso!';
		$response = $notificacoes;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));

	}

	public function criarRecado(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_user_remetente']) || !$post['id_user_remetente']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user_remetente é obrigatório.'
			));
		}

		if(!isset($post['descricao']) || !$post['descricao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo descrição é obrigatório.'
			));
		}

		if(!isset($post['tipo']) || !$post['tipo']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo tipo é obrigatório.'
			));
		}

		if(!isset($post['id_condominio_torre']) || !$post['id_condominio_torre']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_condominio_torre é obrigatório.'
			));
		}

		$recado = new Recado();
		$recado->id_user_remetente = $post['id_user_remetente'];
		$recado->descricao = $post['descricao'];
		$recado->data = date('Y-m-d H:i:s');
		$recado->tipo = $post['tipo'];
		$recado->save();

		if($post['id_condominio_torre'] == 'todos'){

			//$idCondominio = CondominioService::buscarCondominioAtual($reserva->id_user_responsavel);
			$idCondominio = CondominioService::buscarCondominioAtual($post['id_user_remetente']);
			$users = DB::table('sis_users')
			->select('sis_users.*')
			->join('sis_role_users', 'sis_users.id', '=', 'sis_role_users.user_id')
			->join('condomino', 'sis_users.id_condomino', '=', 'condomino.id')
			->join('condominio_unidade', 'condomino.id_condominio_unidade', '=', 'condominio_unidade.id')
			->join('condominio_torre', 'condominio_torre.id', '=', 'condominio_unidade.id_condominio_torre')
			->where('condominio_torre.id_condominio', $idCondominio)
			->get();

		}else{

			//$torre = CondominioTorre::find($post['id_condominio_torre']);
			$users = DB::table('sis_users')
			->select('sis_users.*')
			->join('sis_role_users', 'sis_users.id', '=', 'sis_role_users.user_id')
			->join('condomino', 'sis_users.id_condomino', '=', 'condomino.id')
			->join('condominio_unidade', 'condomino.id_condominio_unidade', '=', 'condominio_unidade.id')
			->where('condominio_unidade.id_condominio_torre', $post['id_condominio_torre'])
			->where('sis_role_users.role_id', '!=', 6) // Não notificar o porteiro
			->get();

		}


		foreach ($users as $user) {
			$recadoDestinatario = new RecadoDestinatario();
			$recadoDestinatario->id_user_destinatario = $user->id;
			$recadoDestinatario->id_recado = $recado->id;
			$recadoDestinatario->save();
		}

		switch ($post['tipo']) {
			case 'A': $tipo = 'S'; $titulo = 'Aviso do Síndico'; break;
			case 'S': $tipo = 'V'; $titulo = 'Solicitação de Vizinho'; break;
			default:
				# code...
				break;
		}

		if($post['id_condominio_torre'] == 'todos'){
			$usuariosFiltrados = CondominioService::notificarCondominio($post['id_user_remetente'], $tipo, $titulo, $post['descricao'], $idCondominio, 'recado', $recado->id);
		}else{
			$usuariosFiltrados = CondominioService::notificarTorre($post['id_user_remetente'], $tipo, $titulo, $post['descricao'], $post['id_condominio_torre'], 'recado', $recado->id);
		}


		$status = true;
		$message = 'Recado criado com sucesso!';
		$response = $recado;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response,
			'usuariosFiltrados' => $usuariosFiltrados
		));
	}

	public function visualizarQuestionamentos(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_questionamento']) || !$post['id_questionamento']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_questionamento é obrigatório.'
			));
		}

		Questionamento::where('id', $post['id_questionamento'])->update(array('visualizado' => 1));

		$status = true;
		$message = 'Questionamento visualizado com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function visualizarNotificacoes(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_notificacao']) || !$post['id_notificacao']){
			Notificacao::where('id_user_destinatario', $post['id_user_destinatario'])->where('id_referencia', $post['id_referencia'])->update(array('status' => 1));
		}else{
			Notificacao::where('id', $post['id_notificacao'])->update(array('status' => 1));
		}



		$status = true;
		$message = 'Notificação visualizada com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarConfiguracoesNotificacao(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}

		$configuracoes  = ConfiguracaoNotificacao::where('id_user', $post['id_user'])->get();

		$response = $configuracoes;
		$status = true;
		$message = 'Configurações buscadas com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarDiasMes(Request $request){
		$post = $request->input();
		$dias = cal_days_in_month(CAL_GREGORIAN, $post['mes'], $post['ano']);
		$return = [];
		for ($i=1; $i<=$dias ; $i++) {
			$countReservas = Reserva::join('condominio_unidade', 'reserva.id_condominio_unidade', '=', 'condominio_unidade.id')
			->join('condominio_torre', 'condominio_unidade.id_condominio_torre', '=', 'condominio_torre.id')
			->where('data',$post['ano'].'-'.$post['mes'].'-'.$i)
			->where('reserva.status', 'A')
			->where('condominio_torre.id_condominio',$post['id_condominio'])->count();

			$countEventosPrivados = EventoPrivado::select('evento_privado.*')
			->join('sis_users', 'evento_privado.id_user_responsavel', '=', 'sis_users.id')
			->where('sis_users.id', $post['id_user'])
			->where('evento_privado.data',$post['ano'].'-'.$post['mes'].'-'.$i)->count();

			if($countReservas || $countEventosPrivados){
				$temEvento = true;
			}else{
				$temEvento = false;
			}

			$diaSemana = date('w',strtotime($post['ano'].'-'.$post['mes'].'-'.$i)) +1;
			switch ($diaSemana) {
				case 1: $dia = 'Dom'; break;
				case 2: $dia = 'Seg'; break;
				case 3: $dia = 'Ter'; break;
				case 4: $dia = 'Qua'; break;
				case 5: $dia = 'Qui'; break;
				case 6: $dia = 'Sex'; break;
				case 7: $dia = 'Sáb'; break;
			}
			$return[] = array(
				'dia' => $i,
				'temEvento' => $temEvento,
				'diaSemana' => $dia
			);
		}
		return json_encode($return);

	}

	public function buscarEventosDia(Request $request){
		$post = $request->input();

		$reservas = Reserva::select('reserva.*')->join('condominio_unidade', 'reserva.id_condominio_unidade', '=', 'condominio_unidade.id')
		->join('condominio_torre', 'condominio_unidade.id_condominio_torre', '=', 'condominio_torre.id')
		->where('data',$post['ano'].'-'.$post['mes'].'-'.$post['dia'])
		->where('condominio_torre.id_condominio',$post['id_condominio'])->where('reserva.status', 'A')->with('espacoComum', 'espacoComumHorario', 'userResponsavel')->get();

		$eventos_privados = EventoPrivado::select('evento_privado.*')
		->join('sis_users', 'evento_privado.id_user_responsavel', '=', 'sis_users.id')
		->where('sis_users.id', $post['id_user'])
		->where('evento_privado.data',$post['ano'].'-'.$post['mes'].'-'.$post['dia'])->with('userResponsavel')->get();

		return json_encode(array(
			'reservas' => $reservas,
			'eventos_privados' => $eventos_privados
		));

	}

	public function buscarEventosSemana(Request $request){
		$post = $request->input();

		$reservas = Reserva::select('reserva.*')->join('condominio_unidade', 'reserva.id_condominio_unidade', '=', 'condominio_unidade.id')
		->join('condominio_torre', 'condominio_unidade.id_condominio_torre', '=', 'condominio_torre.id')
		->where('data','>=',$post['ano'].'-'.$post['mes'].'-'.$post['dia'])
		->where('data','<=',date('Y-m-d', strtotime($post['ano'].'-'.$post['mes'].'-'.$post['dia'].' + 1 week')))
		->where('condominio_torre.id_condominio',$post['id_condominio'])->where('reserva.status', 'A')->with('espacoComum', 'espacoComumHorario', 'userResponsavel')->get();

		$eventos_privados = EventoPrivado::select('evento_privado.*')
		->join('sis_users', 'evento_privado.id_user_responsavel', '=', 'sis_users.id')
		->where('sis_users.id', $post['id_user'])
		->where('evento_privado.data','>=',$post['ano'].'-'.$post['mes'].'-'.$post['dia'])
		->where('evento_privado.data','<=',date('Y-m-d', strtotime($post['ano'].'-'.$post['mes'].'-'.$post['dia'].' + 1 week')))
		->with('userResponsavel')->get();

		return json_encode(array(
			'reservas' => $reservas,
			'eventos_privados' => $eventos_privados
		));

	}

	public function aprovarReserva(Request $request){
		$post = $request->input();

		$reserva = Reserva::find($post['id_reserva']);
		if($reserva){
			if($post['status'] == 'A'){
				$reserva->status = 'A';
				$mensagem = 'O síndico aprovou sua reserva.';
			}elseif($post['status'] == 'R'){
				$reserva->status = 'R';
				$mensagem = 'O síndico recusou sua reserva.';
			}
			$reserva->save();

			$idCondominio = CondominioService::buscarCondominioAtual($reserva->id_user_responsavel);
			$idSindico = CondominioService::buscarSindicoCondominio($idCondominio);
			CondominioService::notificarUsuario($idSindico, 'S', $mensagem, $reserva->espacoComum->nome, $reserva->id_user_responsavel, 'reserva', $reserva->id);
			$status = true;
			//$message = 'Reserva aprovada com sucesso!';
		}else{
			$status = false;
			$mensagem = 'Não existe uma reserva com esse ID.';
		}

		return json_encode(array(
			'status' => $status,
			'message' => $mensagem
		));

	}

	public function sincronizarFacebook(Request $request){
		$post = $request->input();

		$status = false;
		$message = 'Não foi possível sincronizar com os dados do Facebook.';

		$img = \Image::make($post['picture']);
		$id_condominio = CondominioService::buscarCondominioAtual($post['id_user']);
		$tmpFilePath = 'uploads/users/'.$id_condominio.'/';
		$fileName = 'user'.$post['id_user'].'.jpg';
		$img->save($tmpFilePath.$fileName);

		$user = User::find($post['id_user']);
		$user->first_name = $post['name'];
		$user->email = $post['email'];
		$user->thumbnail_principal = $fileName;
		$user->save();

		$status = true;
		$message = 'Facebook sincronizado com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message
		));
	}

	public function criarPrestadorServico(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível criar o registro. Tente novamente mais tarde.";

		if(!isset($post['id_condominio_torre']) || !$post['id_condominio_torre']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Torre é obrigatório.'
			));
		}

		if(!isset($post['id_segmento_servico']) || !$post['id_segmento_servico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Segmento de Serviço é obrigatório.'
			));
		}

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}

		$prestadorServico = new PrestadorServico();
		$prestadorServico->nome = $post['nome'];
		$prestadorServico->id_condominio_torre = $post['id_condominio_torre'];
		$prestadorServico->id_segmento_servico = $post['id_segmento_servico'];
		$prestadorServico->telefone = (isset($post['telefone'])) ? $post['telefone'] : null;
		$prestadorServico->email = (isset($post['email'])) ? $post['email'] : null;
		$prestadorServico->site = (isset($post['site'])) ? $post['site'] : null;

		$prestadorServico->save();

		$status = true;
		$message = 'Prestador criado com sucesso!';
		$response = $prestadorServico;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function editarPrestadorServico(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível editar o registro. Tente novamente mais tarde.";

		if(!isset($post['id_prestador_servico']) || !$post['id_prestador_servico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID é obrigatório.'
			));
		}

		if(!isset($post['id_condominio_torre']) || !$post['id_condominio_torre']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Torre é obrigatório.'
			));
		}

		if(!isset($post['id_segmento_servico']) || !$post['id_segmento_servico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Segmento de Serviço é obrigatório.'
			));
		}

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo nome é obrigatório.'
			));
		}

		$prestadorServico = PrestadordeServico::find($post['id_prestador_servico']);
		$prestadorServico->nome = $post['nome'];
		$prestadorServico->id_condominio_torre = $post['id_condominio_torre'];
		$prestadorServico->id_segmento_servico = $post['id_segmento_servico'];
		$prestadorServico->telefone = (isset($post['telefone'])) ? $post['telefone'] : $prestadorServico->telefone;
		$prestadorServico->email = (isset($post['email'])) ? $post['email'] : $prestadorServico->email;
		$prestadorServico->site = (isset($post['site'])) ? $post['site'] : $prestadorServico->site;

		$prestadorServico->save();

		$status = true;
		$message = 'Prestador editado com sucesso!';
		$response = $prestadorServico;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function deletarPrestadorServico(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível deletar o registro. Tente novamente mais tarde.";

		if(!isset($post['id_prestador_servico']) || !$post['id_prestador_servico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID é obrigatório.'
			));
		}



		PrestadordeServico::where('id',$post['id_prestador_servico'])->delete();


		$status = true;
		$message = 'Prestador deletado com sucesso!';
		$response = $prestadorServico;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarSegmentosServico(){
		$segmentos = SegmentoServico::get();

		return $segmentos;
	}

	public function buscarPrestadoresServico(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível buscar os registros. Tente novamente mais tarde.";

		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Condomínio é obrigatório.'
			));
		}



		$query = PrestadordeServico::select('prestador_de_servico.*')->join('condominio_torre', 'prestador_de_servico.id_condominio_torre', '=', 'condominio_torre.id')
		->where('condominio_torre.id_condominio',$post['id_condominio']);

		if(isset($post['id_segmento_servico'])){
			$query->where('prestador_de_servico.id_segmento_servico', $post['id_segmento_servico'])->get();
		}

		$prestadores = $query->get();

		$status = true;
		$message = 'Prestadores buscados com sucesso!';
		$response = $prestadores;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function alterarFotoPerfil(Request $request){
		if($request->hasFile('file')) {
			//upload an image to the /img/tmp directory and return the filepath.
			$file = $request->file('file');
			$id_condominio = CondominioService::buscarCondominioAtual($request->input('id_user'));
			$tmpFilePath = 'uploads/users/'.$id_condominio.'/';
			$tmpFileName = time() . '-' . $file->getClientOriginalName();
			$file = $file->move(public_path() . '/'.$tmpFilePath, $tmpFileName);
			$path = '/'.$tmpFilePath . $tmpFileName;

			$img = \Image::make($tmpFilePath.$tmpFileName);
			$tmpThumbName = 'thumb_'.$tmpFileName;
			if($img->resize($img->width()/5, $img->height()/5)->save($tmpFilePath.$tmpThumbName)){
				$pathThumb = '/'.$tmpFilePath.$tmpThumbName;
				$user = User::find($request->input('id_user'));
				$user->thumbnail_principal = $tmpThumbName;
				$user->save();
				return response()->json(array('status'=> true, 'file_name'=>$tmpFileName, 'file_name_thumb' => $tmpThumbName), 200);
			}else{
				return response()->json(array('status'=>false,'message' => 'Não foi possível alterar o tamanho da imagem.'), 200);
			}
		} else {
			return response()->json(false, 200);
		}
	}

	public function buscarDadosUsuario(Request $request){
		$params = $request->input();
		$usuario = User::find($params['id_user']);
		$response = null;
		if($usuario){
			$status = true;
			$message = "Dados buscados com sucesso!";
			$response = $usuario;
		}else{
			$status = false;
			$message = "Não existe um usuário com esse ID";
		}
		return response()->json(array('status'=> $status, 'message'=>$message, 'response' => $response), 200);
	}

	public function criarCondominio(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível criar o condomínio. Tente novamente mais tarde.";

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Nome é obrigatório.'
			));
		}

		if(!isset($post['endereco']) || !$post['endereco']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Endereço é obrigatório.'
			));
		}

		if(!isset($post['id_cidade']) || !$post['id_cidade']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Cidade é obrigatório.'
			));
		}

		if(!isset($post['bairro']) || !$post['bairro']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Bairro é obrigatório.'
			));
		}

		if(!isset($post['numero_torres']) || !$post['numero_torres']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Número de Torres é obrigatório.'
			));
		}

		if(!isset($post['numero_andares']) || !$post['numero_andares']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Número de Andares é obrigatório.'
			));
		}

		if(!isset($post['numero_apartamentos_andar']) || !$post['numero_apartamentos_andar']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Número de Apartamentos por andar é obrigatório.'
			));
		}

		if(!isset($post['nome_sindico']) || !$post['nome_sindico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Nome do Síndico é obrigatório.'
			));
		}

		if(!isset($post['email_sindico']) || !$post['email_sindico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo E-mail do Síndico é obrigatório.'
			));
		}

		if(!isset($post['cep']) || !$post['cep']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo CEP é obrigatório.'
			));
		}

		if(User::where('email', $post['email_sindico'])->count()){
			return json_encode(array(
				'status' => false,
				'message' => 'Seu síndico ja foi cadastrado. Favor entrar em contato com ele.'
			));
		}

		$condominio = CondominioService::criarCondominio($post);

		$status = true;
		$message = 'Condomínio criado com sucesso!';
		$response = $condominio;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}

	public function buscarEstados()
	{

		$filtros = \Request::input();
		$query = Estado::select('estado.*')->orderBy('estado.nome', 'ASC');

		$listaEstados = $query->get();

		return $listaEstados;
	}

	public function buscarCidades()
	{
		$filtros = \Request::input();
		$query = Cidade::select('cidade.*')->orderBy('cidade.nome', 'ASC');

		if(isset($filtros['estado'])){
			$query->where('estado', $filtros['estado']);
		}

		$listaCidades = $query->get();

		return $listaCidades;
	}

	public function alterarUsuarioGeradoSindico(){
		$post = \Request::input();

		$result = CondominioService::alterarUsuarioGeradoSindico($post);

		return json_encode($result);
	}



	public function criarPessoaAutorizada(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível alterar o usuário. Tente novamente mais tarde.";

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Nome é obrigatório.'
			));
		}

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}

		if(!isset($post['documento']) || !$post['documento']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Documento é obrigatório.'
			));
		}

		if(!isset($post['observacao']) || !$post['observacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Observação é obrigatório.'
			));
		}

		$PessoaAutorizada = new PessoaAutorizada;
		$PessoaAutorizada->nome = $post['nome'];
		$PessoaAutorizada->id_user_responsavel = $post['id_user'];
		$PessoaAutorizada->observacao = $post['observacao'];
		$PessoaAutorizada->id_condominio_unidade = CondominioService::buscarCondominioUnidadeAtual($post['id_user']);
		$PessoaAutorizada->documento = $post['documento'];
		if($post['thumbnail_principal']){
			$PessoaAutorizada->thumbnail_principal = $post['thumbnail_principal'];
		}
		$PessoaAutorizada->save();

		//$PessoaAutorizada->id ; retorna ID

		$status = true;
		$message = 'Pessoa Autorizada foi criada com sucesso!';
		$response = $PessoaAutorizada;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}



	public function buscaPessoaAutorizada(){
		$post = \Request::input();
		$response = null;
		$status = false;
		$message = "Não foi possível alterar o usuário. Tente novamente mais tarde.";

		if(!isset($post['id_user']) || !$post['id_user']){
		return json_encode(array(
			'status' => false,
			'message' => 'O campo id_user é obrigatório.'
			));
		}

		if(isset($post['id_pessoa_autorizada'])){
			$pessoa = PessoaAutorizada::find($post['id_pessoa_autorizada']);
			if($pessoa){
				$response = $pessoa;
				$status = true;
				$message = 'Registro buscado com sucesso!';
			}else{
				$status = false;
				$message = 'Não foi encontrado um veículo com esse ID.';
			}
		}else{

			$query = PessoaAutorizada::select('pessoa_autorizada.*')
			->where('pessoa_autorizada.id_user_responsavel',$post['id_user']);

			$pessoasAutorizadas = $query->get();

			$response = null;
			if($pessoasAutorizadas){
				$status = true;
				$message = "Dados buscados com sucesso!";
				$response = $pessoasAutorizadas;
			}else{
				$status = false;
				$message = "Não existe com esse ID";
			}

		}
		return response()->json(array('status'=> $status, 'message'=>$message, 'response' => $response), 200);

	}


	public function deletarPessoaAutorizada(){
		$post = \Request::input();
		$response = null;

		if(!isset($post['id_pessoa_autorizada']) || !$post['id_pessoa_autorizada']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID pessoa autorizada é obrigatório.'
			));
		}

		$pessoa = PessoaAutorizada::find($post['id_pessoa_autorizada']);
		if($pessoa){
			$pessoa->delete();
			$status = true;
			$message = 'Pessoa Autorizada removida com sucesso!';
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado uma pessoa autorizada com esse ID.'
			));
		}

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));
	}


	public function editarPessoaAutorizada(){

		$post = \Request::input();
		$response = null;

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Nome é obrigatório.'
			));
		}

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}

		if(!isset($post['documento']) || !$post['documento']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Documento é obrigatório.'
			));
		}

		if(!isset($post['observacao']) || !$post['observacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Observação é obrigatório.'
			));
		}

		$PessoaAutorizada = PessoaAutorizada::find($post['	']);
		$PessoaAutorizada->nome = $post['nome'];
		$PessoaAutorizada->observacao = $post['observacao'];
		$PessoaAutorizada->documento = $post['documento'];
		if($post['thumbnail_principal']){
			$PessoaAutorizada->thumbnail_principal = $post['thumbnail_principal'];
		}

		$PessoaAutorizada->save();
		$status = true;
		$message = 'Pessoa Autorizada editada com sucesso!';
		$response = $PessoaAutorizada;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));

	}


	public function editarPerfilCondomino(Request $request){
		$post = $request->input();

		$status = false;
		$message = 'Não foi possível sincronizar com os dados do Facebook.';

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}

		$userEmail = User::where('email', $post['email'])->first();

		if($userEmail && ($userEmail->id != $post['id_user'])){
			return json_encode(array(
				'status' => false,
				'message' => 'Já existe um usuário com esse e-mail.'
			));
		}

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Nome é obrigatório.'
			));
		}

		if(!isset($post['email']) || !$post['email']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo email é obrigatório.'
			));
		}


		$user = User::find($post['id_user']);

		if(isset($post['password']) && $post['password']){
			if(strlen($post['password']) >= 6){
				$user->password = bcrypt($post['password']);
			}else{
				return json_encode(array(
					'status' => false,
					'message' => 'A senha deve conter no mínimo 6 caracteres.'
				));
			}
		}

		$user->first_name = $post['nome'];
		$user->email = $post['email'];
		$user->save();

		$status = true;
		$message = 'Conta atualizada com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message
		));
	}



	public function buscarTodosUsuariosCondominio(Request $request){
		// enviar apenas id do condominio e o id do grupo
		$post = $request->input();

		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_condominio é obrigatório.'
			));
		}

		if(!isset($post['id_roles']) || !$post['id_roles']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_roles é obrigatório.'
			));
		}

		$torres = CondominioTorre::select('condominio_torre.*')
		->where('condominio_torre.id_condominio', '=', $post['id_condominio'])
		->get();

		foreach ($torres as $key => $torre) {
			$torres[$key]->usuarios = $torre->usersByRole($post['id_roles']);
		}

		$status = true;
		$message = 'Condominos buscados com sucesso!';
		$response = $torres;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));

	}


	public function buscarMotivosTrocaSindico()
	{

		$filtros = \Request::input();
		$query = MotivoTrocaSindico::select('*')->orderBy('nome', 'ASC');

		$listaMotivos = $query->get();

		$status = true;
		$message = 'Motivos buscados com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $listaMotivos
		));
	}



	public function buscarSindicoCondominioApi()
	{
		$post = \Request::input();

		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_condominio é obrigatório.'
			));
		}

		$idSindico = CondominioService::buscarSindicoCondominio($post['id_condominio']);

		$status = true;
		$message = 'Sindico buscado com sucesso!';

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $idSindico
		));
	}

	public function trocarSindicoCondominio(Request $request){
		$post = $request->input();

		if(!isset($post['id_user']) || !$post['id_user']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_user é obrigatório.'
			));
		}

		if(!isset($post['id_novo_sindico']) || !$post['id_novo_sindico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_novo_sindico é obrigatório.'
			));
		}


		if(!isset($post['id_motivo_troca_sindico']) || !$post['id_motivo_troca_sindico']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo motivo troca de síndico é obrigatório.'
			));
		}

		if(!isset($post['observacao']) || !$post['observacao']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo observacao é obrigatório.'
			));
		}



		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo id_condominio é obrigatório.'
			));
		}



		$retorno = 'teste';


		$sindicoAtual = Sentinel::findUserById($post['id_user']);
		$futuroSindico = Sentinel::findUserById($post['id_novo_sindico']);
		$roleSindico = Sentinel::findRoleById(2);
		$roleCondomino = Sentinel::findRoleById(3);

		try {

			$roleSindico->users()->detach($sindicoAtual);
			$roleCondomino->users()->attach($sindicoAtual);

			$roleCondomino->users()->detach($futuroSindico);
			$roleSindico->users()->attach($futuroSindico);

			$historicoSindicoAntigo = HistoricoSindico::where('id_user', $post['id_user'])->orderBy('data_inicio_gestao', 'desc')->first();

			$historicoSindicoAntigo->data_fim_gestao = date('Y-m-d H:i:s');
			$historicoSindicoAntigo->id_motivo_troca_sindico = $post['id_motivo_troca_sindico'];
			$historicoSindicoAntigo->observacao = $post['observacao'];
			$historicoSindicoAntigo->save();


			$historicoSindicoNovo = new HistoricoSindico;
			$historicoSindicoNovo->data_inicio_gestao = date('Y-m-d H:i:s');
			$historicoSindicoNovo->id_condominio = $post['id_condominio'];
			$historicoSindicoNovo->id_user = $post['id_novo_sindico'];
			$historicoSindicoNovo->save();



		} catch (\Illuminate\Database\QueryException $e) {
			return json_encode(array(
				'status' => false,
				'message' => 'Erro de chave primária. Entre em contato com o suporte.'
			));
		}

		$mensagem = 'Parabéns, você é o novo síndico do condomínio, por favor, faça login novamente para que o aplicativo atualize os seus menus de acesso.';
		$titulo = 'Você é o novo Síndico';
		$arrayIds = [];

		array_push($arrayIds, $futuroSindico->udid);


		$teste = CondominioService::sendMessage($arrayIds, $mensagem, $titulo, 'novoSindico', $caminho = null);

		$status = true;
		$message = 'Sindico modificado com sucesso!';
		$response = $retorno;

		return json_encode(array(
			'status' => $status,
			'message' => $message,
			'response' => $response
		));

	}

	public function cancelarReserva(Request $request){
		$post = $request->input();
		$usuario = Sentinel::findUserById($post['id_user']);
		$reserva = Reserva::with('convidados')->find($post['id_reserva']);
		if($reserva){
			$message = "O usuário ".$usuario->first_name." ".$usuario->last_name." cancelou a reserva do espaço comum ".$reserva->espacoComum->nome." do dia ".date('d/m/Y', strtotime($reserva->data));
			if (($usuario->inRole('condomino') || $usuario->inRole('auxiliar')) && $reserva->id_user_responsavel == $usuario->id || !($usuario->inRole('condomino') || $usuario->inRole('auxiliar'))) {
				foreach ($reserva->convidados as $convidado) {
					$convidado->delete();
				}
				$reservaAprovada = $reserva->espacoComum->reserva_aprovada;
				Reserva::where('id',$post['id_reserva'])->delete();
				if($reservaAprovada){
					$idSindico = CondominioService::buscarSindicoCondominio($post['id_condominio']);
					$sindico = \App\User::find($idSindico);
					$status = CondominioService::sendMessage(array(0 => $sindico->udid), $message, "Reserva cancelada", "reservaCancelada", null);
				}
				Notificacao::where('tipo', 'reserva')->where('id_referencia',$post['id_reserva'])->delete();
			}else{
				return json_encode(array(
					'status' => false,
					'message' => 'Você não tem permissões para excluir essa reserva.'
				));
			}
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'A reserva com esse ID não foi encontrada.'
			));
		}

		return json_encode(array(
			'status' => true,
			'message' => 'Reserva cancelada com sucesso.'
		));
	}

	public function criarEventoPrivado(Request $request){
		$post = $request->input();

		if(!isset($post['nome']) || !$post['nome']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Nome é obrigatório.'
			));
		}
		if(!isset($post['data']) || !$post['data']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Data é obrigatório.'
			));
		}
		if($post['data'] < date('Y-m-d')){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Data deve ser posterior à data atual.'
			));
		}
		if(!isset($post['hora_inicial']) || !$post['hora_inicial']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Hora Inicial é obrigatório.'
			));
		}
		if(!isset($post['hora_final']) || !$post['hora_final']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Hora Final é obrigatório.'
			));
		}
		if(!isset($post['local']) || !$post['local']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo Local é obrigatório.'
			));
		}
		if(!isset($post['id_user_responsavel']) || !$post['id_user_responsavel']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID User Responsável é obrigatório.'
			));
		}


		$convidados = (isset($post['convidados'])) ? $post['convidados'] : array();
		unset($post['convidados']);

		$eventoPrivado = new EventoPrivado();
		$eventoPrivado->fill($post);
		$eventoPrivado->save();

		//nl2br(strip_tags(html_entity_decode()));


		foreach ($convidados as $convidado) {
			$novoConvidado = new Convidado();
			$novoConvidado->nome = $convidado['nome'];
			$novoConvidado->documento = $convidado['documento'];
			$novoConvidado->save();

			$epConvidado = new EventoPrivadoConvidado();
			$epConvidado->id_convidado = $novoConvidado->id;
			$epConvidado->id_evento_privado = $eventoPrivado->id;
			$epConvidado->save();
		}


		return json_encode(array(
			'status' => true,
			'message' => 'Evento criado com sucesso.',
			'response' => $eventoPrivado
		));
	}


	public function buscarCondominio(Request $request){
		$post = $request->input();
		if(!isset($post['id_condominio']) || !$post['id_condominio']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Condomínio é obrigatório.'
			));
		}
		$condominio = Condominio::with('torres.unidades.condominos.user')->find($post['id_condominio']);
		if($condominio){
			return json_encode(array(
				'status' => true,
				'message' => 'Condomínio buscado com sucesso.',
				'response' => $condominio
			));
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um condomínio com esse ID.'
			));
		}
	}

	public function deletarEventoPrivado(Request $request){
		$post = $request->input();
		if(!isset($post['id_evento_privado']) || !$post['id_evento_privado']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo ID Evento Prviado é obrigatório.'
			));
		}
		$eventoPrivado = EventoPrivado::with('convidados')->find($post['id_evento_privado']);
		if($eventoPrivado){

			foreach ($eventoPrivado->convidados as $convidado) {
				$convidado->delete();
			}

			$eventoPrivado->delete();

			return json_encode(array(
				'status' => true,
				'message' => 'Evento removido com sucesso.'
			));
		}else{
			return json_encode(array(
				'status' => false,
				'message' => 'Não foi encontrado um evento com esse ID.'
			));
		}
	}

	public function salvarContatoSommelier(){

		$post = \Request::input();

		$user = User::where('email', 'contato@vinumday.com.br')->first();
		$user->email = 'contato@sommelierprofissional.com.br';

		$post['nome']     = !empty($post['nome']) ? $post['nome'] : 'Site Sommelier Profissional';
		$post['telefone'] = '';
		$subject 		  = 'Mensagem enviada pelo site sommelierprofissional.com.br';
		$post['tipo'] 	  = 'sommelier';
		$post['assunto']  = $subject;

        // Create the Transport
		$transport = (new \Swift_SmtpTransport('smtp.dreamhost.com', 587))
		  ->setUsername('noreply@sommelierprofissional.com.br')
		  ->setPassword('n0r3plymail');

		$html = view('emails.contato', $post)->render();

		// Create the Mailer using your created Transport
		$mailer = new \Swift_Mailer($transport);

		// Create a message
		$message = (new \Swift_Message($subject))
		  ->setFrom(['noreply@sommelierprofissional.com.br' => 'Sommelier Profissional'])
		  ->setTo([$user->email => $post['nome']])
		  ->setBody($html, 'text/html')
		  ;

		// Send the message
		$result = $mailer->send($message);

        return response()->json(array(
			'status'  => true,
			'message' => "Mensagem enviada com sucesso!"
		));

	}

	public function salvarMailchimpSommelier(){

		$input = \Request::input();

		$apiKey = '0019c29b4a26764a03ae500930572efa-us4';
        $listId = 'c31218bc38';

		$status  = true;
		$message = "Obrigado por se cadastrar";

		if(!isset($input['email']) || !isset($input['name'])){
			$status  = false;
			$message = "E-mail ou Nome não setado!";
		}elseif(empty($input['email']) || empty($input['name'])){
			$status  = false;
			$message = "E-mail ou Nome não preenchido!";
		}else{

			$mc        = new \NZTim\Mailchimp\Mailchimp($apiKey);
			$result    = $mc->subscribe($listId, $input['email'], ['FNAME' => $input['name']], false);
			$resultado = is_array($result) ? json_encode($result) : $result;

			Log::info($resultado);

		}

		return response()->json(array(
			'status'  => $status,
			'message' => $message
		));

	}

	public function salvarAcessoUsuario(){
		$post = \Request::input();

		if(!isset($post['id_usuario']) || !$post['id_usuario']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo `id_usuario` é obrigatório.'
			));
		}

		if(!isset($post['email']) || !$post['email']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo `email` é obrigatório.'
			));
		}

		if(!isset($post['senha']) || !$post['senha']){
			return json_encode(array(
				'status' => false,
				'message' => 'O campo `senha` é obrigatório.'
			));
		}

		$acesso = AcessoUsuario::where('id_usuario', $post['id_usuario'])->first();
		if(!$acesso){
			$acesso = new AcessoUsuario();
		}

		try {
			$acesso->id_usuario = $post['id_usuario'];
			$acesso->email = $post['email'];
			$acesso->senha = bcrypt($post['senha']);
			$acesso->updated_at = date('Y-m-d H:i:s');
			$acesso->save();

		} catch (\Exception $e) {
			return response()->json([
				'status' => false,
				'message' => $e->getMessage()
			]);
		}
		

		return response()->json([
			'status' => true,
			'message' => 'Acesso salvo com sucesso'
		]);
	}
}