Untitled

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <locale.h>
#include <wchar.h>
#include "functions.h"

typedef struct { 
    char* cards[52]; 
    int values[14]; 
    wchar_t naipes[16][5]; 
} *CardCount;

CardCount clonelistastruct(wchar_t cartas[]){
    CardCount estrutura = malloc(sizeof(*estrutura)); 
    for(int i = 0; i < 16; i++) {
        estrutura->naipes[i][0] = '\0'; 
    }
    for(int i = 0; cartas[i]; i++){
        if (cartas[i]%16 != -1) {
            wcsncat(estrutura->naipes[cartas[i]%16], cartas + i, 1);
            estrutura->values[i] = i;
        }
    }
    memset(estrutura->cards, 0, sizeof(estrutura->cards));
    return estrutura;
}

int sequenciaValida(wchar_t cartamaiorsequencia, wchar_t *cartasatuais, int len_sequencia){
    wchar_t cartaMaisAltaAtual = cartasatuais[len_sequencia - 1];
    if(cartaMaisAltaAtual % 16 == cartamaiorsequencia % 16){
        return cartaMaisAltaAtual > cartamaiorsequencia;
    } else {
        return (cartaMaisAltaAtual % 16) > (cartamaiorsequencia % 16);
    }
}

void recursiva(CardCount estrutura, wchar_t *cartas, int nr_sequencia, wchar_t cartamaiorsequencia, int indicecartaatual, wchar_t *cartasatuais,wchar_t cartaString, wchar_t cartaHex) {
    int lenSequencia = 3;
    if (nr_sequencia == 0 && sequenciaValida(cartamaiorsequencia,cartasatuais,lenSequencia)) {
         for(int i = 0; i < lenSequencia; i++){ 
            wprintf(L"%lc ", cartasatuais[i]);
        }
        wprintf(L"\n");
        return;
    }
    wchar_t arraybidimencionalconjuntos [54][54];
    for (int i = 0; imprimirRespostaseq(cartas,estrutura->naipes[indicecartaatual][i],cartaString,cartaHex,nr_sequencia,arraybidimencionalconjuntos); i++) {
        wchar_t *newCartasatuais = malloc((wcslen(cartasatuais) + 2) * sizeof(wchar_t));
        wcscpy(newCartasatuais, cartasatuais);
        wcsncat(newCartasatuais, &imprimirRespostaseq(cartas,estrutura->naipes[indicecartaatual][i],cartaString,cartaHex,nr_sequencia,arraybidimencionalconjuntos), 1);
        recursiva(estrutura, cartas, nr_sequencia - 1, cartamaiorsequencia, indicecartaatual + 1, newCartasatuais);
        free(newCartasatuais);
    }
}

int verficacaocartas (CardCount estrutura, int nr_sequencia, wchar_t cartamaiorsequencia, int *arrindicecartas) {
    int indicemenor = (cartamaiorsequencia % 16) - nr_sequencia + 1 ;
    int count = 0;
    for (int i = indicemenor; (i <= 14 - nr_sequencia +1); i++) {
        int valor = 0;
        for (int j = i; j < i + nr_sequencia; j++) {
            if (wcslen(estrutura->naipes[j]) == 0) {
                valor = 0;
                break;
            } else {
                valor = 1;
            }
        }
        if (valor == 1) {
            arrindicecartas[count] = i;
            count++;
        }
    }
    return count;
}

void chamadainicialrecursiva(wchar_t *cartas, int nr_sequencia, wchar_t cartamaiorsequencia) {
    wchar_t cartasatuais[2] = L""; 
    CardCount estrutura = clonelistastruct(cartas);
    int arrindicecartas[14];
    int count  = verficacaocartas (estrutura,  nr_sequencia, cartamaiorsequencia, arrindicecartas);
    for(int i = 0; i < count ; i++){
        recursiva(estrutura, cartas, nr_sequencia, cartamaiorsequencia, arrindicecartas[i], cartasatuais);
    }
}