import { Component, OnInit, ChangeDetectorRef } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { CommonModule } from '@angular/common';
import { RouterModule, Router, ActivatedRoute } from '@angular/router';
import { QuestionarioService } from '../../../services/questionario.service';
import { Questionario, TemaPergunta, Pergunta } from '../../../models/questionario.model';
import { AuthService, User } from '../../../services/auth.service';
import { TipoPergunta } from '../../../models/tipoPergunta.enum';

@Component({
  selector: 'app-editar-questionario',
  standalone: true,
  imports: [FormsModule, CommonModule, RouterModule],
  templateUrl: './editar-questionario.component.html',
  styleUrls: ['./editar-questionario.component.css']
})
export class EditarQuestionarioComponent implements OnInit {
  id?: number;

  titulo: string = '';
  dataInicio: string = '';
  prazo: string = '';
  descricao: string = '';
  novaPergunta: string = '';
  mostrarModal: boolean = false;
  temasPergunta: TemaPergunta[] = [];
  todasPerguntas2: Pergunta[] = [];
  perguntasDisponiveis2: Pergunta[] = [];
  temaSelecionado: number | string = '';
  novoTema: string ='';
  modalTema: boolean = false;

  opcoesTipoPergunta: { label: string, value: TipoPergunta }[] = [];
  tipoSelecionado = TipoPergunta.Aberta;

  categoriaSelecionada: string = '';
  //tiposDePergunta: string[] = ['ABERTA', 'LIKERT','SIM/NÃO', 'MULTIPLA_ESCOLHA'];
  //tipoSelecionado: string = 'ABERTA';
  opcoesNovaPergunta: { textoOpcao: string, valor: number | null }[] = [];

  filtroTema: string = '';
  filtroTipo: string = '';

  constructor(
    private questionarioService: QuestionarioService,
    private router: Router,
    private route: ActivatedRoute,
    private cdRef: ChangeDetectorRef,
    private authService: AuthService
  ) {}

  ngOnInit(): void {
    this.id = Number(this.route.snapshot.paramMap.get('id'));
    if (!this.id) {
      alert('ID do questionário inválido.');
      this.router.navigate(['/questionario']);
      return;
    }

    this.listarPerguntasDisponiveis();
    this.listarTemasPerguntas();
    this.carregarTiposPergunta();
  }

  private carregarTiposPergunta(): void {
    const valoresEnum = Object.values(TipoPergunta);
    this.opcoesTipoPergunta = valoresEnum.map(valor => ({
      value: valor,
      label: this.getLabelParaTipo(valor) 
    }));
  }

  private getLabelParaTipo(tipo: TipoPergunta): string {
    switch (tipo) {
      case TipoPergunta.MultiplaEscolha:
        return 'Múltipla Escolha';
      case TipoPergunta.Aberta:
        return 'Aberta';
      case TipoPergunta.Likert:
        return 'Escala Likert';
      case TipoPergunta.SimNao:
        return 'Sim/Não';
      default:
        return tipo;
    }
  }

  listarPerguntasDisponiveis() {
    this.questionarioService.listarPerguntas().subscribe({
      next: (data : Pergunta[]) => {
        this.todasPerguntas2 = data
        this.perguntasDisponiveis2 = [...this.todasPerguntas2]; // exibe todas inicialmente
        this.carregarQuestionario(this.id!);
      },
      error: (erro) =>{
        console.error('Erro ao listar perguntas', erro);
      } 
    });
  }

  listarTemasPerguntas(){
      this.questionarioService.listarTemas().subscribe({
        next: (data: TemaPergunta[])=>{ 
          this.temasPergunta = data;
        },
         error: (erro) => {
          console.error('Erro ao carregar questionários', erro);
        }
      });
  }

  carregarQuestionario(id: number): void {
    this.questionarioService.buscarPorId(id).subscribe({
      next: (q) => {
        this.titulo = q.titulo;
        this.descricao = q.descricao;
        this.dataInicio = q.dataPublicacao?.substring(0, 10) ?? '';
        this.prazo = q.dataValidade?.substring(0, 10) ?? '';

        // Marca perguntas já selecionadas
        if (q.perguntas && q.perguntas.length > 0) {
          const perguntasIds = q.perguntas.map(pergunta => pergunta.id);
          this.perguntasDisponiveis2.forEach(p => {
            p.adicionar = p.id !== undefined && perguntasIds.includes(p.id);
          });
        }
      },
      error: (erro) => {
        console.error('Erro ao carregar questionário', erro);
        alert('Erro ao carregar questionário para edição.');
        this.router.navigate(['/questionario']);
      }
    });
  }  

  salvar(): void {
    const perguntasSelecionadas = this.perguntasDisponiveis2.filter(p => p.adicionar);
    const perguntasSelecionadasIds = perguntasSelecionadas.map(p => p.id).filter((id): id is number => id !== undefined);

    this.authService.currentUser.subscribe((usuarioLogado: User | null) => {
      if (!usuarioLogado) {
        alert('Usuário não autenticado.');
        return;
      }

      const questionario: Questionario = {
        id: this.id,
        titulo: this.titulo,
        descricao: this.descricao,
        dataPublicacao: new Date(this.dataInicio).toISOString().split('T')[0],
        dataValidade: new Date(this.prazo).toISOString().split('T')[0],
        perguntasId: perguntasSelecionadasIds,
        admId: usuarioLogado.id
      };

      this.questionarioService.atualizarQuestionario(questionario).subscribe({
        next: () => {
          alert('Questionário atualizado com sucesso!');
          this.router.navigate(['/questionario']);
        },
        error: (erro) => {
          console.error('Erro ao atualizar questionário', erro);
          alert('Erro ao atualizar questionário.');
        }
      });
    });
  }

  adicionarPergunta() {
    const novaPerguntaParaSalvar = {
      texto: this.novaPergunta,
      idTema: this.temaSelecionado,
      tipo: this.tipoSelecionado,
      // Envia as opções apenas se o tipo for múltipla escolha
      opcoes: this.tipoSelecionado != 'ABERTA' ? this.opcoesNovaPergunta : []
    };
    this.questionarioService.cadastrarNovaPergunta(novaPerguntaParaSalvar).subscribe({
      next: (novaPerguntaCriada) => {
          novaPerguntaCriada.adicionar = true;
          this.todasPerguntas2 = [...this.todasPerguntas2, novaPerguntaCriada];
          this.perguntasDisponiveis2 = [...this.todasPerguntas2];
          this.perguntasDisponiveis2 = [...this.todasPerguntas2];
          //this.perguntas.push(novaPergunta);
          this.novaPergunta = '';
          this.tipoSelecionado = TipoPergunta.Aberta;
          this.temaSelecionado = '';
          this.opcoesNovaPergunta = [];
          this.mostrarModal = false;
          this.cdRef.detectChanges();
        },
        error: (erro) => console.error('Erro ao cadastrar nova pergunta', erro)
    });    
  }

  get isNovaPerguntaInvalida(): boolean{
    if(!this.novaPergunta.trim()){
      return true;
    }
    if(this.tipoSelecionado != 'ABERTA'){
      if(this.opcoesNovaPergunta.length < 2){
        return true;
      }
      const temOpcaoInvalida = this.opcoesNovaPergunta.some(opcao =>{
        return !opcao.textoOpcao.trim() || opcao.valor === null;
      });
      if(temOpcaoInvalida){
        return true;
      }
    }
    return false;
  }

  adicionarOpcao(): void {
    this.opcoesNovaPergunta.push({ textoOpcao: '', valor: null });
  }

  removerOpcao(index: number): void {
    this.opcoesNovaPergunta.splice(index, 1);
  }

  filtrarPerguntasPorTema() {
    if (!this.filtroTema) {
      this.perguntasDisponiveis2 = [...this.todasPerguntas2];
    } else {
      this.perguntasDisponiveis2 = this.todasPerguntas2.filter(
        p => p.idTema === +this.filtroTema
      );
    }
  }

  filtrarPerguntasPorTipo(): void {
    if (!this.filtroTipo) {
      this.perguntasDisponiveis2 = [...this.todasPerguntas2];
    } else {
      this.perguntasDisponiveis2 = this.todasPerguntas2.filter(
        p => p.tipo === this.filtroTipo
      );
    }
  }

  get isFormularioInvalido(): boolean {
    return !this.titulo || !this.prazo || !this.perguntasDisponiveis2.some(p => p.adicionar);
  }

  get isNovoTemaInvalido(): boolean{
    if(this.novoTema.trim() ===''){
      return true;
    }
    return false
  }

  adicionarTema(){
    this.questionarioService.adicionaTema(this.novoTema).subscribe({
      next: () => {
        this.listarTemasPerguntas();
        this.novoTema = '';
        this.modalTema = false;
      },
      error: (err) => {
      console.error('Falha ao adicionar o tema:', err);
      alert('Não foi possível adicionar o tema. Por favor, tente novamente.');
      }
    });
    
  }

  onTipoPerguntaChange(): void {
    switch (this.tipoSelecionado) {
      
      case 'LIKERT':
        this.opcoesNovaPergunta = [
          { textoOpcao: 'Totalmente Insatisfeito', valor: 1 },
          { textoOpcao: 'Insatisfeito', valor: 2 },
          { textoOpcao: 'Neutro', valor: 3 },
          { textoOpcao: 'Satisfeito', valor: 4 },
          { textoOpcao: 'Totalmente Satisfeito', valor: 5 }
        ];
        break;

      case 'SIM/NÃO':
        this.opcoesNovaPergunta = [
          { textoOpcao: 'Não', valor: 0 },
          { textoOpcao: 'Sim', valor: 1 }
        ];
        break;

      case 'MULTIPLA_ESCOLHA':
        this.opcoesNovaPergunta = [
          { textoOpcao: '', valor: 1 },
          { textoOpcao: '', valor: 2 },
          { textoOpcao: '', valor: 3 }
        ];
        break;

      default:
        this.opcoesNovaPergunta = [];
        break;
    }
  }


}
