local Robot = class("Robot")

local PokerType = require("core.poker.PokerType");
local PokerPicker = require("core.poker.PokerPicker");

Robot.enabled = false;

--单机打牌机器人
function Robot:ctor(uid)
    self.uid = uid;
    self.pokers = {};
    self.gongFlag = 0;

    self.gongListener = EventListener.addEventListener(nil,EnumEvent.ROOM_GONG_FLAG,handler(self,self.onGongFlag));
    self.gongResultListener = EventListener.addEventListener(nil,EnumEvent.ROOM_JIN_HUAN_GONG,handler(self,self.onJinHuanGong));
    self.whoShotlistener = EventListener.addEventListener(nil,EnumEvent.GAME_WHO_SHOT,handler(self,self.onWhoShot));
end

function Robot:setPokers(pokers)
    self.pokers = pokers;
    PokerTool.sortPokersDESCByLevel(self.pokers);

    self.pokerType = PokerType:create();
    self:update();
end

function Robot:addCards(pokers)
    for i,v in ipairs(pokers) do
        table.insert(self.pokers,PokerTool.setPokerLevel(v));
    end
end

function Robot:removeCards(pokers)
    for i,v in ipairs(pokers) do
        for j=#self.pokers,1,-1 do
            if v.key == self.pokers[j].key then
                table.remove(self.pokers,j);
                break;
            end
        end
    end
end

--重新计算牌型
function Robot:update()
    if self.pokerType then
        self.pokerType:setPokers(self.pokers);
--        self:printPokerTypes();
    end
end

--该谁出牌
function Robot:onWhoShot(params)
--    if self.uid == UserModel.user_info.uid then
--        self:printPokerTypes();

--        local picker = PokerPicker:create(self.pokers);
--        local pickArr = picker:getMuban();
--        print("提取木板：")
--        self:doPrintType(pickArr);

--        local pickArr = picker:getGangban();
--        print("提取钢板：")
--        self:doPrintType(pickArr);

--        local pickArr = picker:getTongHuaShun();
--        print("提取同花顺：")
--        self:doPrintType(pickArr);

--        local pickArr = picker:getShunzi();
--        print("提取顺子：")
--        self:doPrintType(pickArr);
--    end
    if self.enabled then
        local uid = params.data.uid;
        if uid == self.uid and uid ~= UserModel.user_info.uid then
            self.delayID = delayCall(1,handler(self,self.checkShot));
        elseif uid == self.uid and uid == UserModel.user_info.uid then
            self.delayID = delayCall(1,handler(self,self.checkShot));
        end
    end
end

function Robot:onGongFlag(params)
    local gong_flag = params.data;
    for i,v in ipairs(gong_flag) do
        if v.uid == self.uid then
            self.gongFlag = v.flag;
            if self.uid ~= UserModel.user_info.uid then
                local anys,others = PokerTool.get_any_cards(self.pokers);
                table.sort(others,function(aa,bb)
                    return aa.level > bb.level;
                end);
                if v.flag == 1 then
                    self:jingong(self.uid,others[1]);
                elseif v.flag == 2 then
                    self:huangong(self.uid,others[#others]);
                end
                break;
            end
        end
    end
end

function Robot:onJinHuanGong(params)
    local gd_gong = params.data.gd_gong;
    for i,v in ipairs(gd_gong) do
        if v.jin_gong_uid == self.uid and self.uid ~= UserModel.user_info.uid then
            local poker = PokerTool.getPokerByKey(v.huan_gong_poker_key);
            self:addCards({poker});
            print("得到还贡的牌："..json.encode(poker));
            local poker = PokerTool.getPokerByKey(v.jin_gong_poker_key);
            self:removeCards({poker});
            print("移除进贡的牌："..json.encode(poker));
            self:update();
        elseif v.huan_gong_uid == self.uid and self.uid ~= UserModel.user_info.uid then
            local poker = PokerTool.getPokerByKey(v.jin_gong_poker_key);
            self:addCards({poker});
            print("得到进贡的牌："..json.encode(poker));
            local poker = PokerTool.getPokerByKey(v.huan_gong_poker_key);
            self:removeCards({poker});
            print("移除还贡的牌："..json.encode(poker));
            self:update();
        end
    end
end

function Robot:checkShot()
    self.delayID = nil;
    local shotData = self:getShotData();
    if shotData then
        print(self.uid.."跟牌："..shotData.poker_point);
        self:followShot();
    else
        print(self.uid.."出牌：")
        self:doShot();
    end
end

--打印当前整理的独立牌型
function Robot:printPokerTypes()
    print("当前整理的独立牌型:"..self.uid);
    self:doPrintType(self.pokerType.straightFlushArr);
    self:doPrintType(self.pokerType.straightArr);
    self:doPrintType(self.pokerType.boomArr);
    self:doPrintType(self.pokerType.gangArr);
    self:doPrintType(self.pokerType.muArr);
    self:doPrintType(self.pokerType.threeArr);
    self:doPrintType(self.pokerType.dubbleArr);

    print("单张:"..#self.pokerType.singleArr);
    local str = "";
    for ii,vv in ipairs(self.pokerType.singleArr) do
        str = str .. vv.point .. " ";
    end
    str = str .. "";
    print(str);
end

function Robot:doPrintType(arr)
    if #arr > 0 then
        local ptype = arr[1].poker_type;
        if ptype == EnumPokerType.STRAIGHT_FLUSH then
            print("同花顺:"..#arr);
        elseif ptype == EnumPokerType.STRAIGHT then
            print("顺子:"..#arr);
        elseif ptype == EnumPokerType.BOMB then
            print("炸弹:"..#arr);
        elseif ptype == EnumPokerType.GANG_BAN then
            print("钢板:"..#arr);
        elseif ptype == EnumPokerType.MU_BAN then
            print("木板:"..#arr);
        elseif ptype == EnumPokerType.THREE then
            print("三张:"..#arr);
        elseif ptype == EnumPokerType.DUBBLE then
            print("对子:"..#arr);
        end
        local str = "";
        for i,v in ipairs(arr) do
            for ii,vv in ipairs(v.pokers) do
                str = str .. vv.point .. " ";
            end
            if i ~= #arr then
                str = str .. "  |   ";
            end
        end
        print(str);
    end
end

--跟牌
function Robot:followShot()
    if self.uid == UserModel.user_info.uid then
        local pickArr = self:getPokerTips(self.pokers);
        --如果机器人是帮玩家打，就能管就管
        if #pickArr > 0 then
            self:removeCards(pickArr[1].pokers);
            self:discard(self.uid,pickArr[1].pokers);
        else
            self:pass();
        end
        return;
    end

    local shotData = self:getShotData();
    if self:isPartner(shotData.uid) then
        if shotData.poker_point >= 14 or shotData.poker_gd_type == EnumPokerType.BOMB or shotData.poker_gd_type == EnumPokerType.STRAIGHT_FLUSH then
            self:pass();
            return;
        end
    end
    if shotData.poker_gd_type == EnumPokerType.SINGLE then
        if #self.pokerType.singleArr > 0 then
            local cards = {};
            for i=#self.pokerType.singleArr,1,-1 do
                if self.pokerType.singleArr[i].level > shotData.poker_point then
                    cards[1] = table.remove(self.pokerType.singleArr,i);
                    break;
                end
            end
            if #cards > 0 then
                print("预定牌型可管上家单张:"..self.uid);
                self:removeCards(cards);
                self:discard(self.uid,cards);
            else
                self:checkFightSingle(shotData.poker_point);
--                self:pass();
            end
        else
            self:checkFightSingle(shotData.poker_point);
--            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.DUBBLE then
        if #self.pokerType.dubbleArr > 0 then
            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.dubbleArr);
            if #cards > 0 then
                print("预定牌型可管上家对子:"..self.uid);
                self:removeCards(cards);
                self:discard(self.uid,cards);
            else
                self:checkFightDubble(shotData.poker_point);
--                self:pass();
            end
        else
            self:checkFightDubble(shotData.poker_point);
--            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.STRAIGHT then
        if #self.pokerType.straightArr > 0 then
            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.straightArr);
            if #cards > 0 then
                print("预定牌型可管上家顺子:"..self.uid);
                self:removeCards(cards);
                self:discard(self.uid,cards);
            else
                self:checkFightShunzi(shotData.poker_point);
--                self:pass();
            end
        else
            self:checkFightShunzi(shotData.poker_point);
--            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.MU_BAN then
        if #self.pokerType.muArr > 0 then
            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.muArr);
            if #cards > 0 then
                print("预定牌型可管上家木板:"..self.uid);
                self:removeCards(cards);
                self:discard(self.uid,cards);
            else
                self:checkFightMuban(shotData.poker_point);
--                self:pass();
            end
        else
            self:checkFightMuban(shotData.poker_point);
--            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.GANG_BAN then
        if #self.pokerType.gangArr > 0 then
            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.gangArr);
            if #cards > 0 then
                print("预定牌型可管上家钢板:"..self.uid);
                self:removeCards(cards);
                self:discard(self.uid,cards);
            else
                self:checkFightGangban(shotData.poker_point);
--                self:pass();
            end
        else
            self:checkFightGangban(shotData.poker_point);
--            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.THREE then
        if #self.pokerType.threeArr > 0 then
            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.threeArr);
            if #cards > 0 then
                print("预定牌型可管上家三张:"..self.uid);
                self:removeCards(cards);
                self:discard(self.uid,cards);
            else
                self:checkFightThree(shotData.poker_point);
--                self:pass();
            end
        else
            self:checkFightThree(shotData.poker_point);
--            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.THREE_TWO then
        if #self.pokerType.threeArr > 0 then
            if #self.pokerType.dubbleArr > 0 and self.pokerType.dubbleArr[#self.pokerType.dubbleArr].poker_point < 14 then
                local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.threeArr);
                if #cards > 0 then
                print("预定牌型可管上家三带二:"..self.uid);
                    cards = TableUtil.merge(cards,table.remove(self.pokerType.dubbleArr,#self.pokerType.dubbleArr).pokers);
                    self:removeCards(cards);
                    self:discard(self.uid,cards);
                else
                    self:checkFightThreeTwo(shotData.poker_point);
                end
            else
                self:checkFightThreeTwo(shotData.poker_point);
            end
        else
            self:checkFightThreeTwo(shotData.poker_point);
        end
    elseif shotData.poker_gd_type == EnumPokerType.BOMB then
        if PokerTool.isWangzha(shotData.poker) then
            print("王炸要不起");
            self:pass();
        elseif #self.pokerType.boomArr > 0 then
            local info = self.pokerType:getBiggerBoom(shotData.poker_point,#shotData.poker);
            if info then
                self:checkWeight({info});
            else
                self:pass();
            end
        elseif #self.pokerType.boomArr <= 5 and #self.pokerType.straightFlushArr > 0 then
            local info = self.pokerType.straightFlushArr[#self.pokerType.straightFlushArr];
            if info then
                self:checkWeight({info});
            else
                self:pass();
            end
        else
            self:pass();
        end
    elseif shotData.poker_gd_type == EnumPokerType.STRAIGHT_FLUSH then
        if #self.pokerType.straightFlushArr > 0 then
            local info = nil;
            for i=#self.pokerType.straightFlushArr,1,-1 do
                if self.pokerType.straightFlushArr[i].poker_point > shotData.poker_point then
                    info = self.pokerType.straightFlushArr[i];
                    break;
                end
            end
            if info then
                self:checkWeight({info});
            else
                self:pass();
            end

--            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.straightFlushArr);
--            if #cards > 0 then
--                print("预定牌型可管上家同花顺:"..self.uid);
--                self:removeCards(cards);
--                self:discard(self.uid,cards);
--            else
--                self:pass();
--            end
        elseif #self.pokerType.boomArr > 0 then
            local info = self.pokerType:getBoom6();
            if info then
                self:checkWeight({info});
            else
                self:pass();
            end
        else
            self:pass();
        end
    end
end

function Robot:checkFightSingle(poker_point)
    local pickArr = {};

    if #self.pokerType.dubbleArr > 0 then
        for i,v in ipairs(self.pokerType.dubbleArr) do
            if v.poker_point > 13 and v.poker_point > poker_point then
                local arr = {v.pokers[1]};
                pickArr[#pickArr+1] = {poker_point = arr[1].level,pokers = arr,poker_type=EnumPokerType.SINGLE};
                break;
            end
        end
    end

    if #self.pokerType.threeArr > 0 then
        for i,v in ipairs(self.pokerType.threeArr) do
            if v.poker_point > 13 and v.poker_point > poker_point then
                local arr = {v.pokers[1]};
                pickArr[#pickArr+1] = {poker_point = arr[1].level,pokers = arr,poker_type=EnumPokerType.SINGLE};
                break;
            end
        end
    end

    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

function Robot:checkFightDubble(poker_point)
    local pickArr = {};

    --拆三张
    if #self.pokerType.threeArr > 0 then
        for i,v in ipairs(self.pokerType.threeArr) do
            if v.poker_point > 13 and v.poker_point > poker_point then
                local arr = {v.pokers[1],v.pokers[2]};
                pickArr[#pickArr+1] = {poker_point = arr[1].level,pokers = arr,poker_type=EnumPokerType.DUBBLE};
                break;
            end
        end
    end
    
    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

--检测是否管顺子
function Robot:checkFightShunzi(poker_point)
    local picker = PokerPicker:create(self.pokers);
    local pickArr = picker:getShunzi(poker_point);

    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

--检测是否要管木板
function Robot:checkFightMuban(poker_point)
    local picker = PokerPicker:create(self.pokers);
    local pickArr = picker:getMuban(poker_point);

    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

--检测是否要管钢板
function Robot:checkFightGangban(poker_point)
    local picker = PokerPicker:create(self.pokers);
    local pickArr = picker:getGangban(poker_point);

    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

--检测是否要管三张
function Robot:checkFightThree(poker_point)
    local pickArr = {};
    if #pickArr == 0 then
        if #self.pokerType.gangArr > 0 then
            local shotData = self:getShotData();
            if self.pokerType.gangArr[#self.pokerType.gangArr].poker_point > shotData.poker_point then
                local picker = PokerPicker:create(self.pokerType.gangArr[1].pokers);
                local pickArrThree = picker:getThree(shotData.poker_point);
                for i,v in ipairs(pickArrThree) do
                    pickArr[#pickArr+1] = v;
                end
            end
        end
    end

    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

--检测是否要管三带二
function Robot:checkFightThreeTwo(poker_point)
    local pickArr = {};
    local shotData = self:getShotData();
    if #self.pokerType.threeArr > 0 then
        if #self.pokerType.dubbleArr > 0 then
            local cards = self.pokerType:getBiggerPokers(shotData.poker_point,self.pokerType.threeArr,false);
            if #cards > 0 then
                print("预定牌型可管上家三带二，带了大的对子，判断是否划算");
                cards = TableUtil.merge(cards,self.pokerType.dubbleArr[#self.pokerType.dubbleArr].pokers);
                pickArr[#pickArr+1] = {poker_point = cards[1].level,pokers = cards,poker_type=EnumPokerType.THREE_TWO};
            end
        end
    end

    if #pickArr == 0 then
        if #self.pokerType.gangArr > 0 then
            if #self.pokerType.dubbleArr > 0 and self.pokerType.gangArr[#self.pokerType.gangArr].poker_point > shotData.poker_point then
                local picker = PokerPicker:create(self.pokerType.gangArr[1].pokers);
                local pickArrThree = picker:getThree(shotData.poker_point);
                for i,v in ipairs(pickArrThree) do
                    local cards = TableUtil.merge(v.pokers,self.pokerType.dubbleArr[#self.pokerType.dubbleArr].pokers);
                    pickArr[#pickArr+1] = {poker_point = cards[1].level,pokers = cards,poker_type=EnumPokerType.THREE_TWO};
                end
            end
        end
    end

    for i,v in ipairs(self.pokerType.boomArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.straightFlushArr) do
        pickArr[#pickArr + 1] = v;
    end
    for i,v in ipairs(self.pokerType.wangZha) do
        pickArr[#pickArr + 1] = v;
    end

    self:checkWeight(pickArr);
end

function Robot:checkWeight(pickArr)
    --当前权重
    logE("检测权重："..self.uid);
    local curWeight,curNum = self.pokerType:getWeight();
    if #pickArr > 0 then
        local pokerTypeList = {};
        for i,v in ipairs(pickArr) do
            local _pokers = TableUtil.copyTab(self.pokers);
            self.pokerType:removeFromList(v.pokers,_pokers);

            local newPokerType = PokerType:create();
            newPokerType:setPokers(_pokers);
            newPokerType.pickPokers = v.pokers;

            pokerTypeList[i] = newPokerType;
        end

        local maxPokerType = pokerTypeList[1];
        local maxWeight,maxNum = maxPokerType:getWeight();
        for i,v in ipairs(pokerTypeList) do
            local weight,num = v:getWeight();
            print("牌型权值："..weight,num);
            if weight > maxWeight then
                maxPokerType = v;
                maxWeight,maxNum = maxPokerType:getWeight();
            end
        end
        print(self.uid.."不出牌的权值："..curWeight,curNum);
        if maxWeight > 0 or maxWeight > curWeight then
            self:removeCards(maxPokerType.pickPokers);
            self:discard(self.uid,maxPokerType.pickPokers);
        else
            self:pass();
        end
    else
        self:pass();
    end
end

--主动出牌
function Robot:doShot()
    local cards = self.pokerType:getPokersToPost();
    if cards and #cards > 0 then
        self:removeCards(cards);
        self:discard(self.uid,cards);
    elseif #self.pokerType.boomArr > 0 then
        local cards = table.remove(self.pokerType.boomArr,#self.pokerType.boomArr).pokers;
        self:removeCards(cards);
        self:discard(self.uid,cards);
    elseif #self.pokerType.straightFlushArr > 0 then
        local cards = table.remove(self.pokerType.straightFlushArr,#self.pokerType.straightFlushArr).pokers;
        self:removeCards(cards);
        self:discard(self.uid,cards);
    elseif #self.pokerType.wangZha > 0 then
        local cards = table.remove(self.pokerType.wangZha,#self.pokerType.wangZha).pokers;
        self:removeCards(cards);
        self:discard(self.uid,cards);
    end
end

function Robot:discard(uid,cards)
    if UserModel.where == EnumWhere.ROOM_SINGLE then
        SingleManager.discard(uid,cards);
    elseif UserModel.where == EnumWhere.ROOM_MULTI_GD or UserModel.where == EnumWhere.ROOM_PERSONAL_GD then
        RoomModel.discard(cards);
    end
    self:update();
end

function Robot:pass()
    if UserModel.where == EnumWhere.ROOM_SINGLE then
        SingleManager.pass(self.uid);
    elseif UserModel.where == EnumWhere.ROOM_MULTI_GD or UserModel.where == EnumWhere.ROOM_PERSONAL_GD then
        RoomModel.pass();
    end
end

function Robot:jingong(uid,poker)
    if UserModel.where == EnumWhere.ROOM_SINGLE then
        SingleManager.jingong(uid,poker);
    elseif UserModel.where == EnumWhere.ROOM_MULTI_GD or UserModel.where == EnumWhere.ROOM_PERSONAL_GD then
        RoomModel.jingong(poker);
    end
end

function Robot:huangong(uid,poker)
    if UserModel.where == EnumWhere.ROOM_SINGLE then
        SingleManager.huangong(uid,poker);
    elseif UserModel.where == EnumWhere.ROOM_MULTI_GD or UserModel.where == EnumWhere.ROOM_PERSONAL_GD then
        RoomModel.huangong(poker);
    end
end

--是否是对家
function Robot:isPartner(uid)
    local pos;
    local myPos;
    if UserModel.where == EnumWhere.ROOM_SINGLE then
        pos = SingleManager.getPos(uid);
        myPos = SingleManager.getPos(self.uid);
    elseif UserModel.where == EnumWhere.ROOM_MULTI_GD or UserModel.where == EnumWhere.ROOM_PERSONAL_GD then
        pos = RoomModel.getPos(uid);
        myPos = RoomModel.getPos(self.uid);
    end
    return pos%2 == myPos%2;
end

function Robot:getOtherPokerNum()
    
end

function Robot:getPokerTips(_pokers)
    _pokers = _pokers or self.pokers;
    local pickArr = {};
    local shotData = self:getShotData();
    if shotData then
        local picker = PokerPicker:create(_pokers);
        if shotData.poker_gd_type == EnumPokerType.SINGLE then
            pickArr = picker:getSingle(shotData.poker_point,true);
        elseif shotData.poker_gd_type == EnumPokerType.DUBBLE then
            pickArr = picker:getDubble(shotData.poker_point,nil,true);
        elseif shotData.poker_gd_type == EnumPokerType.THREE then
            pickArr = picker:getThree(shotData.poker_point,true);
        elseif shotData.poker_gd_type == EnumPokerType.THREE_TWO then
            pickArr = picker:getThreeTwo(shotData.poker_point,true);
        elseif shotData.poker_gd_type == EnumPokerType.MU_BAN then
            pickArr = picker:getMuban(shotData.poker_point,true);
        elseif shotData.poker_gd_type == EnumPokerType.GANG_BAN then
            pickArr = picker:getGangban(shotData.poker_point,true);
        elseif shotData.poker_gd_type == EnumPokerType.STRAIGHT then
            pickArr = picker:getShunzi(shotData.poker_point,true);
        elseif shotData.poker_gd_type == EnumPokerType.BOMB then
            if not PokerTool.isWangzha(shotData.poker) then
                pickArr = picker:getBoom(shotData.poker_point,#shotData.poker);
            end
        elseif shotData.poker_gd_type == EnumPokerType.STRAIGHT_FLUSH then
            pickArr = picker:getTongHuaShun(shotData.poker_point,true);
        end
    else
        local _pokerType = PokerType:create();
        _pokerType:setPokers(_pokers);
        for i=#_pokerType.singleArr,1,-1 do
            local poker = _pokerType.singleArr[i];
            pickArr[#pickArr + 1] = {poker_point = poker.level,pokers = {poker},poker_type=EnumPokerType.SINGLE};
        end
        for i=#_pokerType.threeArr,1,-1 do
            local threePokers = _pokerType.threeArr[i].pokers;
            local tmpPokers = TableUtil.copyTab(self.pokers);
            PokerTool.removeFromList(threePokers,tmpPokers);
            local pickTwoArr = _pokerType.dubbleArr;
            for ii=#_pokerType.dubbleArr,1,-1 do
                local dubbleType = _pokerType.dubbleArr[ii];
                local threeTwoArr = TableUtil.merge(threePokers,dubbleType.pokers);
                local pickInfo = {poker_point = threePokers[1].level,pokers = threeTwoArr,poker_type=EnumPokerType.THREE_TWO};
                pickArr[#pickArr+1] = pickInfo;
            end
        end
        self.typeList = {_pokerType.dubbleArr,_pokerType.threeArr,_pokerType.straightArr,_pokerType.muArr,_pokerType.gangArr,_pokerType.boomArr,_pokerType.straightFlushArr};
        for i,v in ipairs(self.typeList) do
            for ii=#v,1,-1 do
                pickArr[#pickArr + 1] = v[ii];
            end
        end
    end
    return pickArr;
end

--获取智能提示
function Robot:getSelectedTips(_pokers)
    _pokers = _pokers or self.pokers;
    local _pokerType = PokerType:create();
    _pokerType:setPokers(_pokers);

    local cards = {};
    
    local shotData = self:getShotData();
    if shotData then
        if shotData.poker_gd_type == EnumPokerType.SINGLE then
            if #_pokerType.singleArr > 0 then
                for i=#_pokerType.singleArr,1,-1 do
                    if _pokerType.singleArr[i].level > shotData.poker_point then
                        cards[1] = table.remove(_pokerType.singleArr,i);
                        break;
                    end
                end
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.DUBBLE then
            if #_pokerType.dubbleArr > 0 then
                cards = _pokerType:getBiggerPokers(shotData.poker_point,_pokerType.dubbleArr);
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.STRAIGHT then
            if #_pokerType.straightArr > 0 then
                cards = _pokerType:getBiggerPokers(shotData.poker_point,_pokerType.straightArr);
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.MU_BAN then
            if #_pokerType.muArr > 0 then
                cards = _pokerType:getBiggerPokers(shotData.poker_point,_pokerType.muArr);
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.GANG_BAN then
            if #_pokerType.gangArr > 0 then
                cards = _pokerType:getBiggerPokers(shotData.poker_point,_pokerType.gangArr);
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.THREE then
            if #_pokerType.threeArr > 0 then
                cards = _pokerType:getBiggerPokers(shotData.poker_point,_pokerType.threeArr);
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.THREE_TWO then
            if #_pokerType.threeArr > 0 then
                if #_pokerType.dubbleArr > 0 then
                    cards = _pokerType:getBiggerPokers(shotData.poker_point,_pokerType.threeArr);
                    if #cards > 0 then
                        cards = TableUtil.merge(cards,table.remove(_pokerType.dubbleArr,#_pokerType.dubbleArr).pokers);
                    end
                end
            end
            if #cards == 0 then
                local info = _pokerType:getBiggerBoom(0,4);
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.BOMB then
            if PokerTool.isWangzha(shotData.poker) then
                print("王炸要不起");
                self:pass();
            elseif #_pokerType.boomArr > 0 then
                local info = _pokerType:getBiggerBoom(shotData.poker_point,#shotData.poker);
                if info then
                    cards = info.pokers;
                end
            elseif #_pokerType.boomArr <= 5 and #_pokerType.straightFlushArr > 0 then
                local info = _pokerType.straightFlushArr[#_pokerType.straightFlushArr];
                if info then
                    cards = info.pokers;
                end
            end
        elseif shotData.poker_gd_type == EnumPokerType.STRAIGHT_FLUSH then
            if #_pokerType.straightFlushArr > 0 then
                local info = nil;
                for i=#_pokerType.straightFlushArr,1,-1 do
                    if _pokerType.straightFlushArr[i].poker_point > shotData.poker_point then
                        info = _pokerType.straightFlushArr[i];
                        break;
                    end
                end
                if info then
                    cards = info.pokers;
                end
            elseif #_pokerType.boomArr > 0 then
                local info = _pokerType:getBoom6();
                if info then
                    cards = info.pokers;
                end
            end
        end
    else
        cards = _pokerType:getPokersToPost();
        if cards and #cards > 0 then

        elseif #_pokerType.boomArr > 0 then
            cards = table.remove(_pokerType.boomArr,#_pokerType.boomArr).pokers;
        elseif #_pokerType.straightFlushArr > 0 then
            cards = table.remove(_pokerType.straightFlushArr,#_pokerType.straightFlushArr).pokers;
        elseif #_pokerType.wangZha > 0 then
            cards = table.remove(_pokerType.wangZha,#_pokerType.wangZha).pokers;
        end
    end
    return cards;
end

function Robot:getShotData()
    local shotData = nil;
    if UserModel.where == EnumWhere.ROOM_SINGLE then
        if #SingleManager.shotDataList > 0 then
            shotData = SingleManager.shotDataList[#SingleManager.shotDataList];
        end
    elseif UserModel.where == EnumWhere.ROOM_MULTI_GD or UserModel.where == EnumWhere.ROOM_PERSONAL_GD then
        if #RoomModel.shotDataList > 0 then
            shotData = RoomModel.shotDataList[#RoomModel.shotDataList];
        end
    end
    return shotData;
end

function Robot:start()
    self.enabled = true;
end

function Robot:stop()
    self.enabled = false;
    if self.delayID then
        removeDelay(self.delayID);
        self.delayID = nil;
    end
end

function Robot:destroy()
    print("Robot:destroy:",self.delayID)
    if self.delayID then
        removeDelay(self.delayID);
        self.delayID = nil;
    end
    EventListener.removeEventListener(nil,self.whoShotlistener);
    EventListener.removeEventListener(nil,self.gongResultListener);
    EventListener.removeEventListener(nil,self.gongListener);
end

return Robot