---
--- Created by 谌建军.
--- DateTime: 2017/12/13 17:04
---
local EXPlayerPokerInfoView = import('.EXPlayerPokerInfoView')
local EXCardType = import('.EXCardType')
local EXCardCheck = import(".CardCheck")

local CardView = {
    btn_card = nil,
    -- 牌号码 （大小）
    card_code_number = 0,
    -- 牌号码 （花色）
    card_code_flower = 0,
    -- 索引
    index = 0
}

local function NewCardView(card, cardcodenum, cardcodeflower)
    local self = {}
    setmetatable(self, { __index = CardView })
    self.btn_card = card
    self.card_code_number = cardcodenum
    self.card_code_flower = cardcodeflower
    self.card_isTouchable = 0
    return self
end

local function tableSortNumber(a, b)
    return a.card_code_number > b.card_code_number
end

local EXPlayerSelfPokerInfoView = {
    _view = nil,
    _mainView = nil,
    _mask_liangpai = nil
}

local M = EXPlayerSelfPokerInfoView

function M.new(view, mainView)
    setmetatable(M, { __index = EXPlayerPokerInfoView })
    local self = setmetatable({}, { __index = M })
    self._view = view
    self._mainView = mainView
    self.gameCtr = ControllerManager.GetController(GameController)
    self:init()
    return self
end

function M:init()
    self.Reset = false
    self.ctr_outpoker = self._view:GetController('output')
    self.outpoker_list = self._view:GetChild('out_card_list')
    self.item_data = json.decode(self._view:GetChild('area_mask').text)
    self.out_card_data = self.item_data['outcard_list']
    self.hand_card_list = self._view:GetChild('hand_card_list')
    self.ctr_hand_card_pos = self._view:GetChild('hand_card_list')
    self._mask_liangpai = self._view:GetChild('mask_liangpai')
    self.card_width = 171
    self.cards_view = self._view:GetChild('hand_poker_c')
    self.card_list = {}
    self.out_card_list = {}
    self.touchMoveFun = handler(self, self.TouchMoving)
    self.ctr_put_card_option = self._view:GetController('out_card_option')
    self.ctr_piao = self._view:GetController('piao')
    self.ctr_piao_value = self._view:GetController('piao_value')
    self.ctr_put_error = self._view:GetController('put_error')
    self.put_error_text = self._view:GetChild('put_error')

    self.ctr_select_card_type = self._view:GetController('select_card_type')
    self.select_card_type_view = self._view:GetChild('choose_type')

    self.text_bomb_score = self._view:GetChild('Score')
    self.ani_bomb_score = self._view:GetTransition('score')
    self.ani_result_score = self._view:GetTransition('score_1')

    self.send_card = {}
    self.tips_click_count = 0
    self:BtnEvent()

    ------------------------------lingmeng------------------------
    self.touchMoveEndFun = handler(self, self.TouchMoveEnd)

    self._view_handCard = self._view:GetChild('List_HandCard')
    self._view_Out = self._view:GetChild('List_Out')

    self._cardCheck = EXCardCheck:InitFlag()
    self._ctr_time_clock = self._view:GetController('time_clock')
    self._view_comp_clock = self._view:GetChild('Comp_Clock')
    --------------------------------------------------------------
end

function M:InitPoker(pokerList, isPlayAni, open)
    if self.cor_init_poker ~= nil then
        coroutine.stop(self.cor_init_poker)
    end
    -- -- print(vardump(self.card_list))
    self.cor_init_poker = nil
    self.card_list = {}
    self.newCard_list = {}
    self._ctr_canSendCard.selectedIndex = 0
    self._flag_ruleCard = false
    self._view_handCard:RemoveChildren(0, -1, true)
    self.scaleW = (GRoot.inst.width * 0.85 - self._view_handCard.columnGap * 14) / 15
    self.scaleH = self.scaleW * 1.3
    if isPlayAni == true then
        self.cor_init_poker =
            coroutine.start(
                function()
                    self._mainView._popEvent = false
                    if self._mainView._rightPanelView._settingView ~= nil then
                        self._mainView._rightPanelView._settingView:SetBtnDismissRoomEnable(false)
                    end
                    table.sort(pokerList)
                    table.sort(self.card_list, tableSortNumber)
                    for i = #pokerList, 1, -1 do
                        if pokerList[i] == 403 then
                            self._flag_ruleCard = true
                        end
                        local card_number_code = self:ChangeOneCodeByFrom(pokerList[i])
                        local card_flower_code = pokerList[i]
                        -- local btn_card = self:CreatPoker(card_number_code, cs, open)
                        local btn_card = self._view_handCard:AddItemFromPool()
                        self:FillPoker(btn_card, "", card_number_code)
                        btn_card.alpha = 0
                        btn_card.touchable = false
                        local card_view = NewCardView(btn_card, card_number_code, card_flower_code)
                        self.card_list[#self.card_list + 1] = card_view
                        btn_card.data = card_view
                        self:AddTouchMoveEvent(self._view_handCard)

                        if i == #pokerList then
                            for j = 1, #self.card_list do
                                local card = self.card_list[j]
                                card.btn_card.touchable = true
                                if open ~= 1 then
                                    -- body
                                    self:AddCardTouchEvent(card)
                                end
                            end
                        end
                    end
                    for j = #self.card_list, 1, -1 do
                        local card_view = self.card_list[j]
                        card_view.index = j

                        card_view.btn_card:TweenMove(self:GetHandCardPos(j, #self.card_list), 0.10)
                        DSTween.To(
                            0.7,
                            1,
                            0.1,
                            function(value)
                                card_view.btn_card:SetScale(value, value)
                            end
                        )
                        DSTween.To(
                            0.7,
                            1,
                            0.1,
                            function(value)
                                card_view.btn_card.alpha = value
                            end
                        )
                        card_view.btn_card.alpha = 1
                    end

                    self._mainView._popEvent = true
                    if self._mainView._rightPanelView._settingView ~= nil then
                        self._mainView._rightPanelView._settingView:SetBtnDismissRoomEnable(true)
                    end
                end
            )
    else
        for i = #pokerList, 1, -1 do
            if not self.newCard_list[pokerList[i] % 100] then
                self.newCard_list[pokerList[i] % 100] = {}
            end
            self.newCard_list[pokerList[i] % 100][math.floor(pokerList[i] / 100)] = (self.newCard_list[pokerList[i] % 100][math.floor(pokerList[i] / 100)] or 0) +
                1
        end
        self:UpdateHandCardsPos()
    end
end

function M:updatePoker()
    local templist = {}
    for i = 1, #self.card_list do
        templist[#templist + 1] = self.card_list[i].card_code_flower
    end
    self:InitPoker(templist, false, 0)
end

function M:AddTouchMoveEvent(list)
    local send_card = {}

    -- list.onTouchBegin:Set(
    --     function(context)
    --         self.send_card = {}
    --         if list.touchable == false then
    --             return
    --         end
    --         local xy = self._view_handCard:GlobalToLocal(Vector2.New(context.inputEvent.x, context.inputEvent.y))
    --         self.touchBegin = xy
    --         Stage.inst.onTouchMove:Add(self.touchMoveFun)
    --         Stage.inst.onTouchEnd:Add(self.touchMoveEndFun)
    --     end
    -- )
end

function M:AddCardTouchEvent(card)
    card.btn_card.onTouchBegin:Set(
        function(context)
            if card.btn_card.touchable == false then
                return
            end
            local cardList   = card.fatherList
            local touchIndex = cardList:GetChildIndex(card.btn_card)
            self._SendCards  = {}
            self.touchCard   = card
            self.touchIndex  = touchIndex
            for i = 0, touchIndex do
                local oncard = cardList:GetChildAt(i)
                self:SetBtnCardColor(oncard.data, 1)
                if oncard.data.zha then
                    for j = 1, 4 do
                        table.insert(self._SendCards, oncard.data.card_code_flower)
                    end
                else
                    table.insert(self._SendCards, oncard.data.card_code_flower)
                end
            end
            local xy = self.touchCard.fatherList:GlobalToLocal(Vector2.New(context.inputEvent.x, context.inputEvent.y))
            self.touchBegin = xy - card.btn_card.xy
            Stage.inst.onTouchMove:Add(self.touchMoveFun)
            Stage.inst.onTouchEnd:Add(self.touchMoveEndFun)
        end
    )
end

function M:zhizhanxuanpai() --智障选牌
    -- body
    local temp_send_card = {}
    for i = 1, #self.send_card do
        if self.send_card[i] ~= self.send_card[i - 1] then
            -- body
            temp_send_card[#temp_send_card + 1] = self.send_card[i]
        end
    end

    local card_map, max_key = self:GetCardMapAndMaxKey(temp_send_card)
    local list_ones = self:CheckOnes(card_map)

    if list_ones ~= nil and #list_ones > 0 then
        for i = 1, #self.card_list do
            self:UpdateCardMove(self.card_list[i].btn_card, false, false)
        end
        for i = 1, #self.send_card do
            for j = 1, #list_ones do
                if self.send_card[i] == list_ones[j][1] then
                    -- body
                    self:UpdateCardMove(self.send_card[i].btn_card, true, false)
                end
            end
        end
        return list_ones
    else
        return {}
    end
end

function M:TouchMoving(context)
    if self._view_handCard == nil then
        return
    end
    local send_card1 = {}
    local xy = self.touchCard.fatherList:GlobalToLocal(Vector2.New(context.inputEvent.x,
        context.inputEvent.y))
    for i = self.touchIndex, 0, -1 do
        local oncard = self.touchCard.fatherList:GetChildAt(i)
        oncard.xy = xy - self.touchBegin - Vector2.New(0, (self.scaleH + self.linegap) * (self.touchIndex - i))
    end

    -- for i = 1, self._view_handCard.numItems do
    --     local card = self._view_handCard:GetChildAt(i - 1).data
    --     if card.btn_card.touchable == false or card.card_isTouchable == 1 then
    --     else
    --         if
    --             (card.btn_card.x + oneCardWidth > min_x or (i == #self.card_list and card.btn_card.x + CardWidth > min_x))
    --             and card.btn_card.x < max_x
    --         then
    --             self:SetBtnCardColor(card, 1)
    --             if #send_card1 == 0 then
    --                 send_card1[1] = card
    --             end
    --             if send_card1[#send_card1] ~= card then
    --                 send_card1[#send_card1 + 1] = card
    --             end
    --         else
    --             self:SetBtnCardColor(card, 0)
    --         end
    --     end
    -- end
    -- self.send_card = send_card1
end

function M:TouchMoveEnd(context)
    local linexy = self._view_handCard:GlobalToLocal(Vector2.New(context.inputEvent.x,
        context.inputEvent.y))
    local allcards = {}
    for k, v in pairs(self.newCard_list) do
        for k1, v1 in pairs(v) do
            if v1 > 0 then
                for i = 1, v1 do
                    local card_flower_code = k1 * 100 + k
                    table.insert(allcards, card_flower_code)
                end
            end
        end
    end
    if linexy.y < self._view:GetChild('n82').y then
        self.gameCtr:SendCard(self._SendCards, allcards)
    else
        if self.touchCard.card_code_flower % 100 < 3 then
            for i = self._view_handCard.numItems - 1, 0, -1 do
                local oneCardList = self._view_handCard:GetChildAt(i):GetChild('list')
                local listxy = oneCardList:GlobalToLocal(Vector2.New(context.inputEvent.x,
                    context.inputEvent.y))
                if listxy.x > 0 and oneCardList:GetChildAt(0).data.card_code_flower % 100 > 2 then
                    for i = 0, oneCardList.numItems - 1 do
                        local oncard = oneCardList:GetChildAt(i)
                        if oncard.data.zha then
                            for j = 1, 4 do
                                table.insert(self._SendCards, oncard.data.card_code_flower)
                            end
                        else
                            table.insert(self._SendCards, oncard.data.card_code_flower)
                        end
                    end
                    self.gameCtr:SendCard(self._SendCards, allcards)
                    break
                end
            end
        end
    end
    for i = 0, self.touchIndex do
        local oncard = self.touchCard.fatherList:GetChildAt(i)
        self:SetBtnCardColor(oncard.data, 0)
        oncard.xy = Vector2.New(0, (self.scaleH + self.linegap) * i)
    end
    -- local fristCard = self._view_handCard:GetChildAt(0)
    -- local CardWidth = fristCard.width
    -- local columnGap = self._view_handCard.columnGap
    -- local oneCardWidth = CardWidth + columnGap
    -- local xy = fristCard:GlobalToLocal(Vector2.New(context.inputEvent.x, context.inputEvent.y))
    -- local downCards = #self.card_list
    Stage.inst.onTouchMove:Remove(self.touchMoveFun)
    Stage.inst.onTouchEnd:Remove(self.touchMoveEndFun)

    -- local max_x
    -- local min_x
    -- if xy.x - self.touchBegin.x > 0 then
    --     max_x = xy.x
    --     min_x = self.touchBegin.x
    -- else
    --     max_x = self.touchBegin.x
    --     min_x = xy.x
    -- end

    -- for k = 1, self._view_handCard.numItems do
    --     local card = self._view_handCard:GetChildAt(k - 1).data
    --     table.insert(currentCard, card.card_code_flower)
    --     if not card.btn_card.selected then
    --         downCards = downCards - 1
    --     end
    --     if card.btn_card.touchable == false or card.card_isTouchable == 1 then
    --     else
    --         self:SetBtnCardColor(card, 0)
    --         if
    --             (card.btn_card.x + oneCardWidth > min_x or (k == #self.card_list and card.btn_card.x + CardWidth > min_x))
    --             and card.btn_card.x < max_x
    --         then
    --             self:UpdateCardMove(card.btn_card, not card.btn_card.selected, false)
    --             if card.btn_card.selected then
    --                 send_card[#send_card + 1] = card
    --             end
    --             --ViewUtil.PlaySound("DuoDuo_PK", "extend/poker/paodekuai/sound/click.mp3")
    --         else
    --             if card.btn_card.selected then
    --                 send_card[#send_card + 1] = card
    --             end
    --         end
    --     end
    -- end

    -- -- ViewUtil.PlaySound('DuoDuo_PK', 'extend/poker/duoduo/sound/click.mp3')

    -- Stage.inst:ResetInputState()

    -- if downCards == 0 then
    --     xuan_card = self:zhizhanxuanpai()
    -- end

    -- if #send_card > 0 then
    --     table.sort(send_card, tableSortNumber)
    --     send_card = #xuan_card > 0 and xuan_card or send_card
    --     self._cardCheck:initCards(send_card,
    --         {
    --             flag = #xuan_card > 0,
    --             flag_allCards = #send_card == self._view_handCard.numItems,
    --             flag_ruleCard = self
    --                 ._flag_ruleCard
    --         })

    --     self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
    -- else
    --     self._ctr_canSendCard.selectedIndex = 0
    -- end
end

-- function M:SetBtnCardColor(card, num)
--     if
--         card.btn_card:GetChildAt(0) ~= nil and card.btn_card:GetChildAt(0):GetChildAt(0) ~= nil and
--         card.btn_card:GetChildAt(0):GetChildAt(0):GetChildAt(0) ~= nil
--     then
--         -- body
--         card.btn_card:GetChildAt(0):GetChildAt(0):GetChildAt(0).color = Color(num, num, num)
--     end

--     --if card.card_code_flower < 500 then
--     --    card.btn_card:GetChildAt(0):GetChildAt(2).color = Color(num,num,num)
--     --    card.btn_card:GetChildAt(0):GetChildAt(3).color = Color(num,num,num)
--     --end
-- end
function M:SetBtnCardColor(card, num)
    card.btn_card:GetController('choose').selectedIndex = num
end

function M:ShowPiao(piao)
    self.ctr_piao.selectedIndex = piao
end

function M:HidePiao()
    self.ctr_piao.selectedIndex = 0
end

function M:ShowOutCardOption2(lastCardList, ctr_select, mustPutMaxCard)
    -- self._cardCheck:InitLastCard(lastCardList, mustPutMaxCard)
    -- self._cardCheck:CheckOutCard(self.card_list)
    -- self.tips_card_list = self._cardCheck:GetTipsList()
    -- self.touchCardSet = self._cardCheck:GetTouchSet()
    -- self.touchCardMap = self._cardCheck:GetTouchCardMap()
    -- self.tips_click_count = 0

    -- print("lingmengShowOutCardOption2", #self.touchCardSet)
    -- pt(self.touchCardSet)
    -- pt(self.touchCardMap)
    -- -- body --在这个方法里添加判断抬起牌是否符合出牌类型(少跑一次手牌循环)
    -- self:UpdateHandCardsColor()

    -- if #self.tips_card_list == 1 then
    --     self:ShowTipsCard(1)
    -- end

    self.ctr_put_card_option.selectedIndex = ctr_select
end

function M:ShowOutCardOption(ctr_select, type, number, length, mustPutMaxCard, play, zdts)
    --for i = 1, #self.out_card_list do
    --    local card = self.out_card_list[i]
    --    self.cards_view:RemoveChild(card.btn_card,true)
    --end
    --self.out_card_list = {}

    -- self.zhizhanctr_select=ctr_select
    -- self.zhizhantype=type
    -- self.zhizhannumber=number
    -- self.zhizhanlength=length
    -- self.zhizhanmustPutMaxCard=mustPutMaxCard
    -- self.zhizhanplay=play
    -- self.zhizhanzdts=zdts
    self.tips_click_count = 0
    self.send_card = {}
    self.tips_card_list = self:GetCardTips(type, number, length, mustPutMaxCard)
    self._ctr_canSendCard.selectedIndex = 0

    if #self.tips_card_list >= 1 then
        -- body --在这个方法里添加判断抬起牌是否符合出牌类型(少跑一次手牌循环)
        self:UpdateHandCardsColor()
    end
    --
    -- 自动提示
    -- if #self.tips_card_list ~= 0 and play~=0 and mustPutMaxCard==false and zdts==1 then
    --     local index = self.tips_click_count % #self.tips_card_list + 1
    --     self:ShowTipsCard(index)
    --     self.tips_click_count = self.tips_click_count + 1
    -- end
    if #self.tips_card_list == 2 and self.tips_card_list[2][1].index == self.tips_card_list[1][1].index then
        if #self.tips_card_list[2] == #self.tips_card_list[1] then
            for i = 1, #self.tips_card_list[2] do
                if self.tips_card_list[2][i].index == self.tips_card_list[1][i].index then
                    self:ShowTipsCard(1)
                end
            end
        end
    elseif #self.tips_card_list == 1 then
        self:ShowTipsCard(1)
    end
    if mustPutMaxCard and play ~= 0 and zdts == 1 then
        -- body
        self:ShowTipsCard(#self.tips_card_list)
    end
    self.ctr_put_card_option.selectedIndex = ctr_select
end

function M:SetOutCardInfo(cardlist, isPass, isAnim)
    self._view_Out:RemoveChildren(0, -1, true)
    if cardlist == nil then
        if isPass == true then
            self.ctr_outpoker.selectedIndex = 2
        else
            self.ctr_outpoker.selectedIndex = 0
        end
    else
        self.ctr_outpoker.selectedIndex = 1
        -- if isAnim then
        --     if self.move_cor then
        --         coroutine.stop(self.move_cor)
        --         self.move_cor = nil
        --     end

        --     for i = 1, #cardlist do
        --         local poker_item = self._view_Out:AddItemFromPool()
        --         local code = self:ChangeCodeByTo(cardlist[i])

        --         self:FillPoker(poker_item, "", cardlist[i])
        --     end
        --     self.move_cor = coroutine.start(function()
        --         coroutine.wait(0.1)
        --         ViewUtil.PlaySound("DuoDuo_PK", "extend/poker/duoduo/sound/chupai.mp3")
        --     end)
        -- else
        for i = 1, #cardlist do
            local poker_item = self._view_Out:AddItemFromPool()

            self:FillPoker2(poker_item, cardlist[i])
        end
        -- end
    end
end

function M:SetOutCardBlack()
    for i = 1, #self.out_card_list do
        local card = self.out_card_list[i]
        if card and card:GetChildAt(0) and card:GetChildAt(0):GetChildAt(0) and card:GetChildAt(0):GetChildAt(0):GetChildAt(0) then
            card:GetChildAt(0):GetChildAt(0):GetChildAt(0).color = Color(0.7, 0.7, 0.7)
        end
    end
end

function M:SetOutCardList(cardlist, isAnim)
    local pos_y = -320
    if isAnim then
        -- self.zhizhanctr_select=0
        -- self.zhizhantype=0
        -- self.zhizhannumber=0
        -- self.zhizhanlength=0
        -- self.zhizhanmustPutMaxCard=0
        -- self.zhizhanplay=0
        -- self.zhizhanzdts=0
        if self.move_cor then
            coroutine.stop(self.move_cor)
            self.move_cor = nil
        end
        local time = 0.1
        for i = 1, #cardlist do
            local card_code_number = cardlist[i]
            for j = 1, #self.card_list do
                local card = self.card_list[j]
                if card_code_number == card.card_code_number then
                    card.btn_card.onTouchBegin:Set(nil)
                    self.out_card_list[#self.out_card_list + 1] = card.btn_card
                    list_remove(self.card_list, card)
                    -- todo 出牌动画
                    local pos =
                        self:GetOutCardEndPokerPos(
                            i,
                            #cardlist,
                            self.cards_view,
                            card.btn_card,
                            self.out_card_data['maxcount_x'],
                            1.5
                        )
                    card.btn_card:TweenMove(Vector2.New(pos.x, pos_y), time)
                    -- self.tween = TweenUtils.TweenFloat(1, 0.7, time, function(x)
                    --     card.btn_card:GetChildAt(0):SetScale(x, x)
                    -- end)
                    card.btn_card:GetChildAt(0):SetScale(1.5, 1.5)
                    break
                end
            end
        end
        self.move_cor =
            coroutine.start(
                function()
                    coroutine.wait(0.05)
                    for i = 1, #self.out_card_list do
                        local card = self.out_card_list[i]
                        self.cards_view:SetChildIndex(card, i - 1)
                    end
                    coroutine.wait(0.1)
                    ViewUtil.PlaySound('DuoDuo_PK', 'extend/poker/duoduo/sound/chupai.mp3')
                end
            )
    else
        for i = 1, #cardlist do
            local poker_item = UIPackage.CreateObject('Extend_Poker_DuoDuo', 'poker7')
            local code = self:ChangeCodeByTo(cardlist[i])
            -- local card_code_obj = UIPackage.CreateObjectFromURL("ui://Extend_Poker_RunFast/" .. code)
            local card_code_obj
            -- if  DataManager.CurrenRoom.pai==0 then
            --         card_code_obj = UIPackage.CreateObjectFromURL("ui://Extend_Poker_RunFast/"..code)
            -- else
            --         card_code_obj = UIPackage.CreateObjectFromURL("ui://Main_Poker/" .. code .. "_2")
            -- end
            -- if code == 310 and DataManager.CurrenRoom.room_config.Heart10 == 2 then
            --     -- body
            --     card_code_obj = UIPackage.CreateObjectFromURL("ui://Extend_Poker_RunFast/" .. code .. "_1")
            -- end
            if DataManager.CurrenRoom.pai == 0 then
                if code == 310 and DataManager.CurrenRoom.room_config.Heart10 == 2 then
                    -- body
                    card_code_obj = UIPackage.CreateObjectFromURL('ui://Extend_Poker_DuoDuo/' .. code .. '_1')
                else
                    card_code_obj = UIPackage.CreateObjectFromURL('ui://Extend_Poker_DuoDuo/' .. code)
                end
            else
                if code == 310 and DataManager.CurrenRoom.room_config.Heart10 == 2 then
                    -- body
                    card_code_obj = UIPackage.CreateObjectFromURL('ui://Extend_Poker_DuoDuo/' .. code .. '_2')
                else
                    card_code_obj = UIPackage.CreateObjectFromURL('ui://Main_Poker/' .. code .. '_2')
                end
            end
            if card_code_obj == nil then
                card_code_obj = UIPackage.CreateObjectFromURL('ui://Main_Poker/00')
            end
            card_code_obj:SetScale(1.5, 1.5)
            poker_item:AddChild(card_code_obj)
            --local poker = self:CreatPoker(cardlist[i],0.7)
            self.cards_view:AddChild(poker_item)
            local pos =
                self:GetOutCardEndPokerPos(
                    i,
                    #cardlist,
                    self.cards_view,
                    poker_item,
                    self.out_card_data['maxcount_x'],
                    1.5
                )
            poker_item.xy = Vector2.New(pos.x, pos_y)
            self.out_card_list[#self.out_card_list + 1] = poker_item
        end
    end
end

-- function M:DeleteHandCards(cardlist)
--     for i = 1, #cardlist do
--         local card_code_number = cardlist[i]
--         for j = 1, #self.card_list do
--             local card = self.card_list[j]
--             if card_code_number == card.card_code_number then
--                 --self.out_card_list[#self.out_card_list + 1] = card
--                 list_remove(self.card_list, card)
--                 -- todo 出牌动画
--                 self.cards_view:RemoveChild(card.btn_card, true)
--                 break
--             end
--         end
--     end
--     self:UpdateHandCardsPos()
-- end
function M:DeleteHandCards(cardlist)
    self.ctr_put_card_option.selectedIndex = 0
    for i = 1, #cardlist do
        local tmpNum = nil
        if self.newCard_list[cardlist[i] % 100] then
            tmpNum = self.newCard_list[cardlist[i] % 100][math.floor(cardlist[i] / 100)]
        end
        if tmpNum then
            if tmpNum == 1 then
                self.newCard_list[cardlist[i] % 100][math.floor(cardlist[i] / 100)] = nil
            else
                self.newCard_list[cardlist[i] % 100][math.floor(cardlist[i] / 100)] = tmpNum - 1
            end
        else
            ViewUtil:ErrorTip("牌型出错，重新加载页面")
            ViewManager.refreshGameView()
        end
        if i == #cardlist then
            if #self.newCard_list[cardlist[i] % 100] == 0 then
                self.newCard_list[cardlist[i] % 100] = nil
            end
        end
    end
    self:UpdateHandCardsPos()
end

function M:UpdateHandCardsPos()
    local maxHeight = 0
    self._view_handCard:RemoveChildrenToPool()
    self._newCardSize = {}
    for k, v in pairs(self.newCard_list) do
        local btn_cardListFather = self._view_handCard:AddItemFromPool()
        btn_cardListFather.width = self.scaleW
        -- btn_cardListFather.height = scaleH*12
        local btn_cardList = btn_cardListFather:GetChild('list')
        btn_cardList:RemoveChildrenToPool()
        self.linegap = btn_cardList.lineGap
        local tmpHeight = 0
        for k1, v1 in pairs(v) do
            local card_number_code = k * 10 + k1
            local card_flower_code = k1 * 100 + k
            if v1 ~= 4 then
                for i = 1, v1 do
                    local btn_card = btn_cardList:AddItemFromPool()
                    btn_card.height = self.scaleH
                    self:FillPoker2(btn_card, card_flower_code)
                    -- self.cards_view:AddChild(btn_card)
                    local card_view = NewCardView(btn_card, card_number_code, card_flower_code)
                    card_view.fatherList = btn_cardList
                    self.card_list[#self.card_list + 1] = card_view
                    btn_card.data = card_view
                    tmpHeight = tmpHeight + 1
                    self:AddCardTouchEvent(card_view)
                end
            else
                local btn_card = btn_cardList:GetFromPool('')
                btn_cardList:AddChildAt(btn_card, 0)
                btn_card.height = self.scaleH
                self:FillPoker2(btn_card, card_flower_code, "_z")
                -- self.cards_view:AddChild(btn_card)
                local card_view = NewCardView(btn_card, card_number_code, card_flower_code)
                card_view.fatherList = btn_cardList
                card_view.zha = true
                self.card_list[#self.card_list + 1] = card_view
                btn_card.data = card_view
                tmpHeight = tmpHeight + 1
                self:AddCardTouchEvent(card_view)
            end
            self._newCardSize[k1] = tmpHeight
        end

        if tmpHeight > maxHeight then
            maxHeight = tmpHeight
        end
    end
    self._view:GetChild('n82').y = self._view_handCard.height -
        (self.scaleH + (self.scaleH + self.linegap) * (maxHeight - 1) + 50)
end

function M:ResetPoker()
    self.Reset = true
    for i = 1, #self.card_list do
        local card_view = self.card_list[i]
        self:UpdateCardMove(card_view.btn_card, false, false)
    end
    self.send_card = {}
    self.Reset = false
end

function M:UpdateCardMove(btn_card, isSelected, isPlay)
    btn_card.selected = isSelected
    -- local card_Move = btn_card
    -- local xy = isSelected == true and Vector2.New(0, -65) or Vector2.New(0, 0)
    -- if isPlay then
    --     -- body
    --     card_Move:TweenMove(xy, 0)
    -- else
    --     card_Move:TweenMove(xy, 0)
    -- end
end

--
-- function M:UpdateHandCardsColor()
--     local send_card = {}
--     for i = 1, #self.card_list do
--         local card_view = self.card_list[i]
--         local num = card_view.btn_card.touchable == true and 0 or 1
--         self:SetBtnCardColor(card_view, num)
--         if card_view.btn_card.selected and card_view.btn_card.touchable then
--             table.insert(send_card, card_view)
--         end
--     end
--     if #send_card > 0 then
--         table.sort(send_card, tableSortNumber)
--         self._cardCheck:initCards(send_card, false, #send_card == self._view_handCard.numItems)
--         self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
--     else
--         self._ctr_canSendCard.selectedIndex = 0
--     end
-- end

function M:UpdateHandCardsColor()
    local send_card = {}
    for i = 1, #self.card_list do
        local card_view = self.card_list[i]
        if self.touchCardMap[math.floor(card_view.card_code_number / 10)] or #self.touchCardSet == 0 then
            card_view.btn_card.touchable = true
            self:SetBtnCardColor(card_view, 0)
        else
            card_view.btn_card.touchable = false
            card_view.btn_card.selected = false
            self:SetBtnCardColor(card_view, 1)
        end
        if card_view.btn_card.selected and card_view.btn_card.touchable then
            table.insert(send_card, card_view)
        end
    end
    if #send_card > 0 then
        table.sort(send_card, tableSortNumber)
        self._cardCheck:initCards(send_card, { flag = false, flag_allCards = #send_card == self._view_handCard.numItems })
        self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
    else
        self._ctr_canSendCard.selectedIndex = 0
    end
end

function M:BtnEvent()
    self.btn_not_put = self._view:GetChild('btn_not_put')
    self.btn_tips = self._view:GetChild('Btn_Tip') -- 覆盖
    self.btn_sendCards = self._view:GetChild('Btn_SendCard')
    self._ctr_canSendCard = self.btn_sendCards:GetController('can')

    self.btn_sendCards.onClick:Set(
        function()
            if self.Reset then
                return
            end
            if self._ctr_canSendCard.selectedIndex == 0 then
                return
            end
            local send_card = {}
            self.send_card = {}
            local currentCard = {}
            for i = 1, #self.card_list do
                local card = self.card_list[i]
                table.insert(currentCard, card.card_code_flower)
                if card.btn_card.selected then
                    send_card[#send_card + 1] = card.card_code_flower
                    self.send_card[#self.send_card + 1] = card
                end
            end

            if #send_card == 0 then
                self:ErrorTip('请选择要出的牌')
            else
                self.gameCtr:SendCard(send_card, currentCard)
            end
        end
    )
    self.btn_tips.onClick:Set(
        function()
            --printlog("wwwwwwwwwww111111111111111111111111")
            --pt(self.tips_card_list)
            if self.tips_card_list ~= nil and #self.tips_card_list ~= 0 then
                local index = self.tips_click_count % #self.tips_card_list + 1
                self:ShowTipsCard(index)
                self.tips_click_count = self.tips_click_count + 1
            end
        end
    )
    -- 过
    self.btn_not_put.onClick:Set(
        function()
            self.ctr_put_card_option.selectedIndex = 0
            self.gameCtr:SendPass()
        end
    )

    local function click_piao()
        self.ctr_piao.selectedIndex = 0
        self.gameCtr:SendPiao(tonumber(self.ctr_piao_value.selectedPage))
    end

    local btn_piao0 = self._view:GetChild('piao0')
    btn_piao0.onClick:Set(click_piao)

    local btn_piao1 = self._view:GetChild('piao1')
    btn_piao1.onClick:Set(click_piao)

    local btn_piao2 = self._view:GetChild('piao2')
    btn_piao2.onClick:Set(click_piao)

    local btn_piao3 = self._view:GetChild('piao3')
    btn_piao3.onClick:Set(click_piao)

    local btn_piao5 = self._view:GetChild('piao5')
    btn_piao5.onClick:Set(click_piao)

    local btn_piao8 = self._view:GetChild('piao8')
    btn_piao8.onClick:Set(click_piao)
end

function M:ShowTipsCard(index)
    print("lingmengShowTipsCard")
    local item = self.tips_card_list[index]
    for i = 1, #self.card_list do
        local card = self.card_list[i]
        local isExsit = false
        for j = 1, #item do
            if item[j] == self.card_list[i] then
                self:UpdateCardMove(card.btn_card, true, false)
                isExsit = true
            end
        end
        if isExsit == false then
            self:UpdateCardMove(card.btn_card, false, false)
        end
    end
    pt(item)
    self._cardCheck:initCards(item)
    self._ctr_canSendCard.selectedIndex = self._cardCheck:CheckCards() and 1 or 0
end

function M:GetHandCardOffset(count)
    local start = -90 ---54

    local offset = 0
    if count > 10 then
        offset = start - count + 26
    else
        offset = -30
    end
    return 20
end

function M:GetHandCardPos(index, card_count)
    local x, y = 0, -20
    local offset = self:GetHandCardOffset(card_count)
    local middle_x = self.cards_view.width / 2
    local start_x = middle_x - (card_count / 2 * (self.card_width + offset)) + (offset / 2)
    x = start_x + (self.card_width + offset) * (index - 1)
    return Vector2.New(x, y)
end

function M:GetHandCardPos1(index, card_count)
    local x, y = 0, -18
    local offset = self:GetHandCardOffset(card_count)
    local middle_x = self.cards_view.width / 2
    local start_x = middle_x - (card_count / 2 * (self.card_width + offset)) + (offset / 2)
    x = start_x + (self.card_width + offset) * (index - 1)
    return x, y
end

function M:ErrorTip(error_text)
    if self.cor_init_poker ~= nil then
        coroutine.stop(self.cor_init_poker)
    end
    self.cor_init_poker = nil
    self.cor_init_poker =
        coroutine.start(
            function()
                self.put_error_text.text = error_text
                self.ctr_put_error.selectedIndex = 1
                coroutine.wait(2)
                self.ctr_put_error.selectedIndex = 0
            end
        )
end

--EXCardType
--None = 0,
--OneCard = 1,
--OnePair = 2,
--Three = 3,
--Pairs = 4,
--ThreeAndTwo = 5,
--ThreeAndOne = 6,
--Plane = 7,
--PlaneAndTwo = 8,
--PlaneAndOne = 9,
--Straight = 10,
--Bomb = 11
function M:GetCardTips(type, number, length, mustPutMaxCard, tip_templist)
    local tip_list = {}
    local sidaisan = false
    local touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
    --printlog("aaaaaaaaaaaaacccccccccccccccccccc11111111111111111111111111111")
    --pt(self.card_list)
    local card_map, max_key = self:GetCardMapAndMaxKey(self.card_list)
    --printlog("aaaaaaaaaaaaaaaaaa222222222222222222222222222222222222222   ",max_key)
    --pt(card_map)
    if type == EXCardType.None then
        if DataManager.CurrenRoom.is_new_bout then
            tip_list = self:NewBoutTips(card_map)
        end
        return tip_list, touch_key_list
    elseif type == EXCardType.Bomb then
        tip_list, touch_key_list = self:CheckBomb(card_map, number, length)
    else
        local list_type, list_bomb = {}, {}
        local touch_type, touch_bomb
        list_bomb, touch_bomb = self:CheckBomb(card_map, 0, 4)

        local card_templist = membe_clone(self.card_list)

        if list_bomb ~= nil and tip_templist == nil then
            -- body
            for i = 1, #list_bomb do
                local templist_bomb = list_bomb[i]
                for j = 1, #templist_bomb do
                    for k = 1, #card_templist do
                        if templist_bomb[j] == card_templist[k] then
                            -- body
                            list_remove(card_templist, card_templist[k])
                        end
                    end
                end
            end
            card_map, max_key = self:GetCardMapAndMaxKey(card_templist)
        end

        if type == EXCardType.OneCard then
            -- if mustPutMaxCard then
            --     number = max_key - 1
            --     self:ErrorTip("下家报单，请出最大的牌 ")
            -- end
            list_type, touch_type = self:CheckOneCard(card_map, number, length)
        elseif type == EXCardType.OnePair then
            list_type, touch_type = self:CheckOnePair(card_map, number, length)
        elseif type == EXCardType.Three then
            list_type, touch_type = self:CheckThree(card_map, number, length)
        elseif type == EXCardType.Pairs then
            list_type, touch_type = self:CheckPairs(card_map, number, length)
        elseif type == EXCardType.ThreeAndTwo then
            list_type, touch_type = self:CheckThreeAndTwo(card_map, number, length)
        elseif type == EXCardType.ThreeAndOne then
            list_type, touch_type = self:CheckThreeAndOne(card_map, number, length)
        elseif type == EXCardType.Plane then
            list_type, touch_type = self:CheckPlane(card_map, number, length, 0)
        elseif type == EXCardType.PlaneAndTwo then
            list_type, touch_type = self:CheckPlane(card_map, number, length, 2)
        elseif type == EXCardType.PlaneAndOne then
            list_type, touch_type = self:CheckPlane(card_map, number, length, 1)
        elseif type == EXCardType.Straight then
            list_type, touch_type = self:CheckStraight(card_map, number, length)
        elseif type == EXCardType.FourAndtThree then
            list_type, touch_type = self:CheckBomb(card_map, 0, 4)
            if #list_type > 0 then
                -- body
                sidaisan = true
            end
        end
        card_map, max_key = self:GetCardMapAndMaxKey(self.card_list)
        tip_list = self:GetMergeAllList(list_type, list_bomb)
        --list_bomb, touch_bomb = self:CheckBomb(card_map, 0, 4)
        touch_key_list = self:GetMergeAllList(touch_type, touch_bomb)
        local tip_templist2 = {}
        if tip_templist == nil then
            -- body
            tip_templist2 = self:GetCardTips(type, number, length, mustPutMaxCard, tip_list)
        end
        if #tip_templist2 > 0 then
            -- body
            tip_list = self:GetMergeAllList(tip_list, tip_templist2)
        end
    end

    if (tip_templist ~= nil and sidaisan == false and #tip_templist >= 1) then
        -- body
        self:SetNotTouchCard(touch_key_list, card_map)
    end

    return tip_list
end

-- 合并多个list
function M:GetMergeAllList(...)
    local lists = { ... }
    local merge_list = {}
    for i = 1, #lists do
        local list_item = lists[i]
        for j = 1, #list_item do
            merge_list[#merge_list + 1] = list_item[j]
        end
    end

    return merge_list
end

function M:NewBoutTips(pokerMap)
    local new_bout_list = {}
    for k, v in pairs(pokerMap) do
        new_bout_list[#new_bout_list + 1] = v
    end
    return new_bout_list
end

function M:CheckOneCard(pokerMap, num, length)
    local one_card_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return one_card_list, touch_key_list
    end
    for k, v in pairs(pokerMap) do
        if k > num and #v == 1 then
            one_card_list[#one_card_list + 1] = { v[1] }
            touch_key_list[#touch_key_list + 1] = k
        end
    end
    for k, v in pairs(pokerMap) do
        if k > num and #v ~= 1 then
            one_card_list[#one_card_list + 1] = { v[1] }
            touch_key_list[#touch_key_list + 1] = k
        end
    end
    return one_card_list, touch_key_list
end

function M:CheckOnePair(pokerMap, num, length)
    local one_pair_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return one_pair_list, touch_key_list
    end
    for k, v in pairs(pokerMap) do -- 从三条和对子里面提取
        if #v > 1 and k > num then
            one_pair_list[#one_pair_list + 1] = { v[1], v[2] }
            touch_key_list[#touch_key_list + 1] = k
        end
    end
    return one_pair_list, touch_key_list
end

function M:CheckThree(pokerMap, num, length)
    local three_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return three_list, touch_key_list
    end
    for k, v in pairs(pokerMap) do
        if #v > 2 and k > num then
            three_list[#three_list + 1] = { v[1], v[2], v[3] }
            touch_key_list[#touch_key_list + 1] = k
        end
    end
    return three_list, touch_key_list
end

function M:CheckPairs(pokerMap, num, length)
    local pairs_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return pairs_list, touch_key_list
    end
    local pair_length = length / 2
    local number_start = num - pair_length + 2
    local number_end = 15 - pair_length
    for i = number_start, number_end do
        local item_all_list = {}
        for j = i, i + pair_length - 1 do
            local item_list = pokerMap[j]
            if item_list == nil then
                break
            elseif #item_list < 2 then
                break
            else
                item_all_list[#item_all_list + 1] = item_list[1]
                item_all_list[#item_all_list + 1] = item_list[2]
            end
            if j == i + pair_length - 1 then
                pairs_list[#pairs_list + 1] = item_all_list
                for k = i, i + pair_length - 1 do
                    touch_key_list[#touch_key_list + 1] = k
                end
            end
        end
    end
    return pairs_list, touch_key_list
end

function M:CheckThreeAndOne(pokerMap, num, length)
    local three_and_one_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return three_and_one_list, touch_key_list
    end
    for k, v in pairs(pokerMap) do
        if #v >= 3 and k > num then
            three_and_one_list[#three_and_one_list + 1] = { v[1], v[2], v[3] }
            touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
        end
    end
    return three_and_one_list, touch_key_list
end

function M:CheckThreeAndTwo(pokerMap, num, length)
    local three_and_two_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return three_and_two_list, touch_key_list
    end
    for k, v in pairs(pokerMap) do
        if #v >= 3 and k > num then
            three_and_two_list[#three_and_two_list + 1] = { v[1], v[2], v[3] }
            touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
        end
    end
    return three_and_two_list, touch_key_list
end

function M:CheckStraight(pokerMap, num, length)
    local straight_list = {}
    local touch_key_list = {}
    if #self.card_list < length then
        return straight_list, touch_key_list
    end
    local number_start = num - length + 2
    local number_end = 15 - length
    for i = number_start, number_end do
        local item_all_list = {}
        for j = i, i + length - 1 do
            local item_list = pokerMap[j]
            if item_list == nil then
                break
            else
                item_all_list[#item_all_list + 1] = item_list[1]
            end
            if j == i + length - 1 then
                straight_list[#straight_list + 1] = item_all_list
                for k = i, i + length - 1 do
                    touch_key_list[#touch_key_list + 1] = k
                end
            end
        end
    end
    return straight_list, touch_key_list
end

function M:CheckBomb(pokerMap, num, length)
    local bomb_list = {}
    local touch_key_list = {}
    local threeA = DataManager.CurrenRoom.room_config.threeA
    if threeA == 0 then
        -- body
        if #self.card_list < length then
            return bomb_list, touch_key_list
        end
    else
        if #self.card_list < 3 then
            return bomb_list, touch_key_list
        end
    end

    for k, v in pairs(pokerMap) do
        if #v == 4 and k > num then
            bomb_list[#bomb_list + 1] = v
            touch_key_list[#touch_key_list + 1] = k
        end
        if threeA == 1 and #v == 3 and k == 14 then
            bomb_list[#bomb_list + 1] = v
            touch_key_list[#touch_key_list + 1] = k
        end
    end

    return bomb_list, touch_key_list
end

function M:CheckPlane(pokerMap, num, length, and_num)
    local plane_list = {}
    local touch_key_list = {}
    local l = and_num + 3
    local pair_length = length / l
    local number_start = num - pair_length + 2
    local number_end = 15 - pair_length
    for i = number_start, number_end do
        local item_all_list = {}
        for j = i, i + pair_length - 1 do
            local item_list = pokerMap[j]
            if item_list == nil then
                break
            elseif #item_list < 3 then
                break
            else
                item_all_list[#item_all_list + 1] = item_list[1]
                item_all_list[#item_all_list + 1] = item_list[2]
                item_all_list[#item_all_list + 1] = item_list[3]
            end
            if j == i + pair_length - 1 then
                plane_list[#plane_list + 1] = item_all_list
                touch_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
            end
        end
    end
    return plane_list, touch_key_list
end

function M:SetNotTouchCard(touch_key_list, card_map)
    local all_key_list = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }
    for i = 1, #all_key_list do
        local key = all_key_list[i]
        local isExsit = self:IsExistByList(touch_key_list, key)
        if isExsit == false then
            local key_card_item = card_map[key]
            if key_card_item ~= nil then
                for j = 1, #key_card_item do
                    local card = key_card_item[j]
                    card.btn_card.touchable = false
                    self:UpdateCardMove(card.btn_card, false, false)
                end
            end
        end
    end
end

function M:IsExistByList(list, item)
    for i = 1, #list do
        if list[i] == item then
            return true
        end
    end
    return false
end

function M:GetCardByNumber(list, number)
    for i = 1, #list do
        if list[i].card_code_number == number then
            return list[i]
        end
    end
    return nil
end

function M:GetCardMapAndMaxKey(pokerList)
    local map, max_key = {}, 0
    for i = 1, #pokerList do
        local number = math.floor(pokerList[i].card_code_number / 10)
        if number > max_key then
            max_key = number
        end
        if map[number] == nil then
            map[number] = { pokerList[i] }
        else
            map[number][#map[number] + 1] = pokerList[i]
        end
    end
    return map, max_key
end

-- function M:CheckOnes(pokerMap, num, length)
--     local one_card_list = {}
--     local touch_key_list = {}
--     local text = {}
--     local text2 = {}
--     local x = 0
--     if #self.card_list < length then
--         return one_card_list, touch_key_list
--     end
--     for k, v in pairs(pokerMap) do
--         text = {}
--         text2 = {}
--         if k > num then
--             for l, p in pairs(pokerMap) do
--                 for i = 0, length - 1 do
--                     if l == k + i and l ~= 15 and l ~= 16 then
--                         -- body
--                         text[#text + 1] = { p[1] }
--                         text2[#text2 + 1] = l
--                         if #text >= length then
--                             -- body
--                             local x = #one_card_list
--                             local y = #touch_key_list
--                             for i = 1, #text - 1 do
--                                 one_card_list[x + 1] = text[1]
--                                 touch_key_list[y + 1] = text2[2]
--                                 -- for i, v in pairs(text2[i + 1]) do
--                                 --     if v ~= nil then
--                                 --         table.insert(touch_key_list[x + 1], v)
--                                 --     end
--                                 -- end
--                                 for i, v in pairs(text[i + 1]) do
--                                     if v ~= nil then
--                                         table.insert(one_card_list[x + 1], v)
--                                     end
--                                 end
--                             end
--                         end
--                     end
--                 end
--             end
--         end
--     end
--     return one_card_list, touch_key_list, length
-- end

function M:CheckOnes(pokerMap)
    local one_card_list = {}
    local old_k = 0
    for k, v in pairs(pokerMap) do
        if #one_card_list == 0 then
            table.insert(one_card_list, v)
            old_k = k
        else
            if k == 15 then
                break
            end
            if k ~= old_k + 1 and #one_card_list >= 5 then
                break
            end
            if k ~= old_k + 1 then
                one_card_list = {}
            end
            table.insert(one_card_list, v)
            old_k = k
        end
    end
    if #one_card_list < 5 then
        one_card_list = {}
    end
    return one_card_list
end

function M:Clear()
    self:PlayScore(nil)
    self:SetOutCardInfo(nil, false)
    self.card_list = {}
    self.out_card_list = {}
    self._view_handCard:RemoveChildren(0, -1, true)
    self._flag_ruleCard = false
    --  self.mask_liangpai:RemoveChildren(0,-1,true)
end

function M:ClearCheck()
    self.card_list = {}
    self.out_card_list = {}
    self._view_handCard:RemoveChildren(0, -1, true)
end

function M:Destroy()
    Stage.inst.onTouchMove:Remove(self.touchMoveFun)
    Stage.inst.onTouchEnd:Remove(self.touchMoveEndFun)
end

return M