#include "set_game.h"

#include <string.h>
#include <stdlib.h>

#include "debug_info.h"
#include "log.h"
#include "code_generator.h"
#ifdef HAS_GM67
#include "gm67_drv.h"
#endif

COMPONENT_GET_NODE(SetGame, set_game)
COMPONENT_GET_CONFIG(SetGame, set_game)

#define SET_GAME_IS_XXXX_SET(CardA,CardB,CardC,ATTRIBUTE)              \
    bool set_game_is_##ATTRIBUTE##_set(SetCard_t* CardA,               \
                                       SetCard_t* CardB,               \
                                       SetCard_t* CardC) {             \
    bool res = false;                                                  \
    if(CardA->Info.ATTRIBUTE == CardB->Info.ATTRIBUTE){                \
        if(CardB->Info.ATTRIBUTE == CardC->Info.ATTRIBUTE){            \
            if(CardA->Info.ATTRIBUTE == CardC->Info.ATTRIBUTE){        \
                res = true;                                            \
            }                                                          \
        }                                                              \
    }                                                                  \
    if(CardA->Info.ATTRIBUTE != CardB->Info.ATTRIBUTE){                \
        if(CardB->Info.ATTRIBUTE != CardC->Info.ATTRIBUTE){            \
            if(CardA->Info.ATTRIBUTE != CardC->Info.ATTRIBUTE){        \
                res = true;                                            \
            }                                                          \
        }                                                              \
    }                                                                  \
    return res;                                                        \
 }


bool set_game_proc_one(uint8_t num) {
    bool res = false;
    LOG_PARN(SET_GAME, "Proc:%u", num);
    SetGameHandle_t* Node = SetGameGetNode(  num);
    if (Node) {
#ifdef HAS_GM67
        Gm67Handle_t* Gm67Node=Gm67GetNode(Node->scanner_num);
        if(Gm67Node){
            if(Gm67Node->unptoc_frame){
                LOG_DEBUG(SET_GAME, "%s", SetNodeToStr(Node));
                SetCardInfo_t Card;
                Card.byte = Gm67Node->DataFixed[0];
                res = set_game_add_card(num, Card);
                Gm67Node->unptoc_frame = false ;

                res = set_game_seek_set(num);
            }
        }
#endif
    }
    return res;
}

bool set_game_init_custom(void) {
    bool res = true ;
    srand(time(0));
    log_level_get_set(SET_GAME, LOG_LEVEL_INFO  );
    return res;
}

bool set_game_is_uniq_ll(  SetGameHandle_t* Node,SetCardInfo_t Card){
    bool res = true;
    uint8_t i = 0 ;
    for(i=0;i<Node->card_cnt;i++){
        if(Card.byte == Node->Cards[i].Info.byte){
            res = false ;
        }
    }
    return res;
}


bool set_game_is_set_index(const SetInstance_t* const SetNode, uint8_t index){
    bool res = false ;
    if(index==SetNode->CardA.index){
    	res = true;
    }
    if(index==SetNode->CardB.index){
    	res = true;
    }
    if(index==SetNode->CardC.index){
    	res = true;
    }
    return res;
}

bool set_game_add_card(uint8_t num, SetCardInfo_t Card){
    bool res = false;
    SetGameHandle_t* Node = SetGameGetNode(  num);
    if(Node) {
        LOG_DEBUG(SET_GAME,"New:%s",SetCardInfoToStr( Card)  );
        if( Node->card_cnt < SET_GAME_TOTAL_ON_TABLE){
            //is uniq?
            res = set_game_is_uniq_ll(Node,Card);
            if(res) {
                LOG_INFO(SET_GAME,"+%s",SetCardInfoToStr( Card)  );
                Node->Cards[Node->card_cnt].Info=Card;
                Node->Cards[Node->card_cnt].index = Node->card_cnt;
                Node->card_cnt++;
                res = true;
            } else {
                LOG_ERROR(SET_GAME,"Duplicate:%s",SetCardInfoToStr( Card)  );
            }
        } else {
            LOG_ERROR(SET_GAME,"TooManyCardsOnnTable:%s",SetCardInfoToStr( Card) );
        }
        SetGameDiag(Node);
    }
    return res;
}



SET_GAME_IS_XXXX_SET(CardA,CardB,CardC,color)

SET_GAME_IS_XXXX_SET(CardA,CardB,CardC,filling)

SET_GAME_IS_XXXX_SET(CardA,CardB,CardC,quantity)

SET_GAME_IS_XXXX_SET(CardA,CardB,CardC,shape)


bool set_game_is_set(SetCard_t* CardA, SetCard_t* CardB, SetCard_t* CardC) {
    bool res = false;

    res = set_game_is_color_set(CardA, CardB,CardC) ;
    if(res) {
        res = false;
        res = set_game_is_filling_set(CardA, CardB, CardC) ;
        if(res){
            res = false;
            res = set_game_is_quantity_set(CardA, CardB, CardC) ;
            if(res){
                res = false;
                res = set_game_is_shape_set(CardA, CardB, CardC) ;
            }
        }
    }

    return res;
}

int uint32_compare(const void * x1, const void * x2)  {
  return ( *(uint32_t*)x1 - *(uint32_t*)x2 );              // если результат вычитания равен 0, то числа равны, < 0: x1 < x2; > 0: x1 > x2
}

bool set_game_is_set_uniq(SetGameHandle_t* Node , SetInstance_t* Instance){
    bool res = true ;
    uint32_t i =0;
    for (i=0;i<Node->set_cnt;i++){
        if(Instance->qword==Node->SetArray[i].qword){
            res = false ;
            break;
        }
    }
    return res;
}

bool set_game_seek_set(uint8_t num){
    bool res = false ;
    SetGameHandle_t* Node = SetGameGetNode(num);
    uint32_t cur_arr[3] ={0};
    uint32_t i =0;
    uint32_t j =0;
    uint32_t k =0;
    for(i=0;i<Node->card_cnt;i++){
        for(j=0;j<Node->card_cnt;j++){
            for(k=0;k<Node->card_cnt;k++){
                if(i!=j){
                    if(i!=k){
                        if(j!=k){
                            res = set_game_is_set(
                                    &Node->Cards[i],
                                    &Node->Cards[j],
                                    &Node->Cards[k]);
                            if(res){
                                cur_arr[0] =i;
                                cur_arr[1] =j;
                                cur_arr[2] =k;
                                size_t item_size = sizeof(uint32_t);
                                qsort((void *)cur_arr, (size_t)3,   item_size, uint32_compare);


                                SetInstance_t Instance;
                                Instance.qword = 0;
                                Instance.CardA=Node->Cards[cur_arr[0]];//2
                                Instance.CardB=Node->Cards[cur_arr[1]];//2
                                Instance.CardC=Node->Cards[cur_arr[2]];//2
                                res = set_game_is_set_uniq(Node,&Instance);
                                if (res) {
                                    Node->SetArray[Node->set_cnt]=Instance;
                                    Node->set_cnt++;
                                    res = true;
                                    LOG_INFO(SET_GAME,"%u,SpotNewSet:%u,%u,%u!",Node->set_cnt,cur_arr[0],cur_arr[1],cur_arr[2]);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    if(Node->set_cnt){
        LOG_INFO(SET_GAME,"SetCnt:%u",Node->set_cnt);
    }else {
        LOG_ERROR(SET_GAME,"NoSets");

    }

    return res;
}

bool set_game_init_one(uint8_t num) {
    LOG_WARNING(SET_GAME, "Init:%u", num);
    bool res = false;
    const SetGameConfig_t* Config = SetGameGetConfig(num);
    if(Config) {
        LOG_WARNING(SET_GAME, "%s", SetGameConfigToStr(Config));
        SetGameHandle_t* Node = SetGameGetNode(num);
        if(Node) {
            LOG_INFO(SET_GAME, "%u", num);
            Node->num = Config->num;
            Node->scanner_num = Config->scanner_num;
            Node->valid = true;
            Node->set_cnt = 0;
            Node->card_cnt = 0;
            memset(Node->StepLog,0,sizeof(Node->StepLog));
            SetGameDiag(Node) ;
            res = true;
        }
    }
    return res;
}

COMPONENT_INIT_PATTERT(SET_GAME, SET_GAME, set_game)
COMPONENT_PROC_PATTERT(SET_GAME, SET_GAME, set_game)