#include <stdio.h>
#include <stdlib.h>

typedef struct TipoAluno{
    int exigencia;
    int semestre;
    int ordem;
    struct TipoAluno *proximo;
}TipoAluno;

typedef struct FilaAluno{
    TipoAluno *frente;
    TipoAluno *tras;
}TipoFilaAluno;

typedef struct TipoQuarto{
    int conservacao;
    int semestres_alocado;
    struct TipoQuarto *proximo;
}TipoQuarto;


typedef struct FilaQuarto{
    TipoQuarto *inicio;
    TipoQuarto *fim;
}TipoFilaQuarto;

void CriaFilaQuarto(TipoFilaQuarto *fila){
fila->inicio = NULL;
fila->fim = NULL;
}

void InsereQuarto(int padrao,int semestres_alocado,TipoFilaQuarto *fila){
TipoQuarto * NovoQuarto = (TipoQuarto*)malloc(sizeof(TipoQuarto));
NovoQuarto->proximo = NULL;
    NovoQuarto->conservacao = padrao;
    NovoQuarto->semestres_alocado = semestres_alocado;
    if(fila->inicio == NULL){
        fila->inicio = NovoQuarto;
        fila->fim = NovoQuarto;
    }
    else{
        fila->fim->proximo = NovoQuarto;
        fila->fim = NovoQuarto;
    }
}

void RetiraAluno(TipoFilaAluno *fila){
    TipoAluno* aux;
    aux = fila->frente;
    fila->frente=fila->frente->proximo;
    free(aux);
}

void RetiraQuarto(TipoFilaQuarto *fila){
    TipoQuarto * aux;
    aux = fila->inicio;
    fila->inicio=fila->inicio->proximo;
    free(aux);}
void PrintarFilaQuarto(TipoFilaQuarto *fila){
    TipoQuarto *auxiliar;
    int j=1;
    auxiliar = fila->inicio;

    if(fila->inicio == NULL){
        printf("\nNenhum apartamento disponivel\n");
    }

    else{
        while(auxiliar!= NULL){
                printf("\nPadrao do apartamento %d: %d\n",j,auxiliar->conservacao);
                printf("Quantidade de semestres indisponivel:%d\n",auxiliar->semestres_alocado);
                j++;
            auxiliar = auxiliar->proximo;
        }
    }
}

void CriaFilaAluno(TipoFilaAluno *fila){
    fila->frente = NULL;
    fila->tras = NULL;
}

void InsereAluno(int padrao,int semestres,int ordem,TipoFilaAluno *fila){
    TipoAluno *NovoAluno = (TipoAluno*)malloc(sizeof(TipoAluno));
    NovoAluno->ordem = ordem;
    NovoAluno->proximo = NULL;
    NovoAluno->exigencia = padrao;
    NovoAluno->semestre = semestres;
    if(fila->frente == NULL){
        fila->frente = NovoAluno;
        fila->tras = NovoAluno;
    }
    else{
        fila->tras->proximo = NovoAluno;
        fila->tras = NovoAluno;
    }
}

void PrintarFilaAluno(TipoFilaAluno *fila){
    TipoAluno *auxiliar;
    int j=1;
    auxiliar = fila->frente;
    if(fila->frente == NULL){
        printf("Fila de Alunos Vazia\n");
    }
    else{
        while(auxiliar!= NULL){
        printf("\nPadrao minimo exigido pelo Aluno %d: %d\n",auxiliar->ordem,auxiliar->exigencia);
        printf("Numero de semestre que o Aluno %d cursou: %d\n",auxiliar->ordem,auxiliar->semestre);
        auxiliar = auxiliar->proximo;
        j++;
    }
    }
}
int AlocaSemestre(int tamanho_fila_de_alunos,int tamanho_fila_de_quartos,TipoFilaAluno *F_aluno,TipoFilaQuarto * F_quarto,TipoFilaAluno* F_alunoAlocada,TipoFilaQuarto* F_quartoAlocada)
{
    TipoQuarto * AUX;
    int exigencia,conservacao,semestres,i=0,j=0,k=0,l=0,tamanho=0,ordem;
    while(i < tamanho_fila_de_alunos)
        {
        for(j=0;j < tamanho_fila_de_quartos;)
            {
            k=0;l=0;
            conservacao = F_quarto->inicio->conservacao;
            exigencia = F_aluno->frente->exigencia;
            semestres = F_aluno->frente->semestre;
            ordem = F_aluno->frente->ordem;
            if(F_aluno->frente->exigencia <= F_quarto->inicio->conservacao)
                {

                    RetiraAluno(F_aluno);
                    InsereAluno(exigencia,semestres,ordem,F_alunoAlocada);
                    RetiraQuarto(F_quarto);
                    InsereQuarto(conservacao,semestres,F_quartoAlocada);
                    i++;
                    tamanho_fila_de_quartos--;
                    if(tamanho_fila_de_quartos == 0){
                        k=2;
                        break;

                    }
                    while(l < tamanho_fila_de_quartos - j)
                        {
                        conservacao = F_quarto->inicio->conservacao;
                        InsereQuarto(conservacao,0,F_quarto);
                        RetiraQuarto(F_quarto);
                        l++;
                        }
                    k = 1;

                    break;
                }

            else
                {
                    conservacao = F_quarto->inicio->conservacao;
                    InsereQuarto(conservacao,0,F_quarto);
                    RetiraQuarto(F_quarto);
                    j++;
                }



      }

    if(k==0)                        /*Com k=0, nao foi achado nenhum quarto para o aluno*/
        {
    exigencia = F_aluno->frente->exigencia;
    semestres = F_aluno->frente->semestre;
    ordem = F_aluno->frente->ordem;
    RetiraAluno(F_aluno);
    InsereAluno(exigencia,semestres,ordem,F_aluno);
    i++;
        }
    if(k==2)        /* caso os quartos acabem ele ordenara a fila de alunos*/
        {   l=0;
            while(l <tamanho_fila_de_alunos-i)
                {
                exigencia = F_aluno->frente->exigencia;
                semestres = F_aluno->frente->semestre;
                ordem = F_aluno->frente->ordem;
                RetiraAluno(F_aluno);
                InsereAluno(exigencia,semestres,ordem,F_aluno);
                i++;}
            }
            }


AUX = F_quartoAlocada->inicio;  /* a variavel "tamanho" representa quantos quartos a fila de quartos alocadas possui*/
while(AUX != NULL){
    AUX = AUX->proximo;
    tamanho++;}




return tamanho;
}
int main(){
    TipoFilaAluno FilaDeAlunos,FilaDeAlunosAlocada;
    TipoAluno* AUX;
    TipoQuarto* AUX2;
    TipoFilaQuarto FilaDeQuartos,FilaDeQuartosAlocada;
    CriaFilaAluno(&FilaDeAlunos);
    CriaFilaAluno(&FilaDeAlunosAlocada);
    CriaFilaQuarto(&FilaDeQuartos);
    CriaFilaQuarto(&FilaDeQuartosAlocada);

    int tamanho_fila_de_alunos=0,tamanho_fila_de_quartos=0,tamanho_fila_de_quartos_alocada=0,padrao;
    int padrao_exigido,quantidade_semestres,tempo=0;
    int i=0,j=0;
    printf("Digite o tamanho da fila de espera de Alunos: ");
    scanf("%d",&tamanho_fila_de_alunos);

    for(i=0;i<tamanho_fila_de_alunos;i++){
        printf("\nQual o padrao minimo exigido pelo aluno %d: \n",(i+1));
        scanf("%d",&padrao_exigido);
        printf("\nQuantos semestres o aluno %d vai ficar?\n",(i+1));
        scanf("%d",&quantidade_semestres);
        InsereAluno(padrao_exigido,quantidade_semestres,i+1,&FilaDeAlunos);
    }

    printf("Digite o tamanho da fila de quartos a serem usados: ");
    scanf("%d",&tamanho_fila_de_quartos);

    for(i=0;i<tamanho_fila_de_quartos;i++){
        printf("Qual o padrao do quarto %d: ",(i+1));
        scanf("%d",&padrao);

        InsereQuarto(padrao,0,&FilaDeQuartos);
        }

    printf("\n----fila de alunos-----------\n");
    PrintarFilaAluno(&FilaDeAlunos);
    printf("\n---fila de quartos------------\n");
    PrintarFilaQuarto(&FilaDeQuartos);
        tamanho_fila_de_quartos_alocada = AlocaSemestre(tamanho_fila_de_alunos,tamanho_fila_de_quartos,&FilaDeAlunos,&FilaDeQuartos,&FilaDeAlunosAlocada,&FilaDeQuartosAlocada);



        /*AUX = FilaDeAlunos.frente;
        while(FilaDeAlunos.frente != NULL)
            {   if(FilaDeAlunos.frente->exigencia >= 5)
                    {
                        FilaDeAlunos.frente->exigencia = FilaDeAlunos.frente->exigencia-5;
                    }
                else{FilaDeAlunos.frente->exigencia =0;}

                FilaDeAlunos.frente = FilaDeAlunos.frente->proximo;
            }
        FilaDeAlunos.frente = AUX;


        i=0;
        while(i<tamanho_fila_de_quartos_alocada && tamanho_fila_de_quartos_alocada != 0){
                    padrao = FilaDeQuartosAlocada.inicio->conservacao;
                    quantidade_semestres = FilaDeQuartosAlocada.inicio->semestres_alocado;
                    if(FilaDeQuartosAlocada.inicio->semestres_alocado == 0)
                        {
                            InsereQuarto(padrao,0,&FilaDeQuartos);
                            RetiraQuarto(&FilaDeQuartosAlocada);
                            tamanho_fila_de_quartos_alocada--;
                            }
                    else{

                            InsereQuarto(padrao,quantidade_semestres,&FilaDeQuartosAlocada);
                            RetiraQuarto(&FilaDeQuartosAlocada);
                            i++;


                    }

}
AUX2 = FilaDeQuartosAlocada.inicio;
        while(FilaDeQuartosAlocada.inicio != NULL)
            {
                    FilaDeQuartosAlocada.inicio->semestres_alocado--;
                    FilaDeQuartosAlocada.inicio= FilaDeQuartosAlocada.inicio->proximo;
            }
        FilaDeQuartosAlocada.inicio = AUX2;
        tempo++;*/


    printf("\n-----fila de alunos novo----------\n");
    PrintarFilaAluno(&FilaDeAlunos);
    printf("\n------fila de quartos novo---------\n");
    PrintarFilaQuarto(&FilaDeQuartos);
    printf("\n------fila de alunos alocados---------\n");
    PrintarFilaAluno(&FilaDeAlunosAlocada);
    printf("\n----fila de quartos alocados-----------\n");
    PrintarFilaQuarto(&FilaDeQuartosAlocada);
    printf("O tempo foi de:%d",tempo);



  return 0;
}