local TX_Protocol = import(".Protocol")
local FZTipList = import(".main.FZData")
local TX_GameEvent = import(".GameEvent")

local M = {}

--- Create a new GameController
function M.new()
  setmetatable(M,{__index = GameController})
  local self = setmetatable({}, {__index = M})
  self:init("测试麻将")
  self.class = "TX_GameController"
  return self
end

function M:init(name)
	GameController.init(self,name)
   
	self._eventmap[TX_Protocol.GAME_EVT_PLAYER_DEAL] = self.OnEventSendCards
    self._eventmap[TX_Protocol.GAME_EVT_CHANGE_ACTIVE_PLAYER] = self.OnEventTurn

    self._eventmap[TX_Protocol.GAME_EVT_DRAW] = self.OnEventTakeCard
    self._eventmap[TX_Protocol.GAME_EVT_DISCARD_TIP] = self.OnEventOutHint
    self._eventmap[TX_Protocol.GAME_EVT_DISCARD] = self.OnEventOutCard

    self._eventmap[TX_Protocol.GAME_EVT_FZTIPS] = self.OnEventFzTips
    self._eventmap[TX_Protocol.GAME_EVT_ACTION] = self.OnEventFzAction

    self._eventmap[TX_Protocol.GAME_EVT_HU] = self.OnEventHu

    self._eventmap[TX_Protocol.GAME_EVT_RESULT1] = self.OneventResult1
    self._eventmap[TX_Protocol.GAME_EVT_RESULT2] = self.OnEventResult2
    self._eventmap[TX_Protocol.GAME_EVT_NIAO] = self.OnEventNiao
    self._eventmap[TX_Protocol.GAME_EVT_PIAOTIP] = self.OnEventPiaoTip
    self._eventmap[TX_Protocol.GAME_EVT_PIAO] = self.OnEventPiao
end

local __pre_delete_card = false
-- 发送出牌指令到服务器
function M:SendOutCard(card, callback)
    local _data = {}
    _data["card"] = card
    local _room = self._room
    local _client = ControllerManager.GameNetClinet 
    _client:send(TX_Protocol.GAME_DIS_CARD, _data)

    -- 进行预删牌处理
    local p = _room.self_player
    _room.curren_outcard_seat = -1
    list_remove(p.card_list,card)
    table.sort(p.card_list, ViewUtil.HandCardSort2)
    p.hand_left_count = p.hand_left_count - 1
    if not p.outcard_list then p.outcard_list = {} end
    p.outcard_list[#p.outcard_list+1] = card
    __pre_delete_card = true
    callback()
end


-- 发送放子选择到服务器
function M:SendAction(id)
    local _data = {}
    _data["id"] = id
    local _client = ControllerManager.GameNetClinet 
    _client:send(TX_Protocol.GAME_ACTION, _data)
end


function M:HideHutips()
	DispatchEvent(self._dispatcher,TX_GameEvent.HuTipsAction)
end

function M:OnEventSendCards(evt_data)
    if ViewManager.GetCurrenView().dview_class == LobbyView then
        self:ReturnToRoom()
        return
    end

    local  _room = self._room
    if not _room.room_config.piao_niao or _room.self_player.entrust then
        _room.curren_round = _room.curren_round + 1
    end
    if _room.curren_round > 0 then _room.playing = true end
	
	printlog("开始发牌===========>>>")
	pt(evt_data)
	
	local room = DataManager.CurrenRoom
	--printlog(evt_data.laiziCard)
	--printlog(evt_data.laiziCard2)
	--printlog(evt_data.laiziCard3)
	
	room.laiziInfo={}
	if evt_data.laiziCard2>0 then
		table.insert(room.laiziInfo,evt_data.laiziCard)
		table.insert(room.laiziInfo,evt_data.laiziCard2)
		if evt_data.laiziCard3>0 then
			--table.insert(room.laiziInfo,evt_data.laiziCard3)
			local str=string.sub(evt_data.laiziCard3,2)
			for i=1,4 do
				table.insert(room.laiziInfo,tonumber(i..str))
			end
		end
	else
		room.laiziInfo=nil
	end
	
	if evt_data.laiziCard3>0 then
		DispatchEvent(self._dispatcher,TX_GameEvent.SendLaiZi,evt_data.laiziCard3,evt_data.laiziCard3,0,true )
	end
	
	
			
	
    -- _room.SelfPlayer.AutoOutCard = false
    local handcards = evt_data["card_list"]
    local p = _room.self_player
    local seat = evt_data["bank_seat"]
    self._cacheEvent:Enqueue(function()
        _room.banker_seat = seat
        for i=1,#_room.player_list do
            _room.player_list[i].hand_left_count = 7
            _room.player_list[i].fz_list = {}
            _room.player_list[i].card_list = {}
        end
        p.card_list = handcards
		self._room.self_player.hand_left_count = #handcards
		table.sort( handcards, ViewUtil.HandCardSort2 )
        DispatchEvent(self._dispatcher,TX_GameEvent.SendCards, p)
    end)      
end


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


function M:OnEventOutCard(evt_data)
	printlog("出牌事件===========>>>")
	pt(evt_data)
    local seat = evt_data["seat"]
    local card = evt_data["card"]
    local ting_list = nil
    local p = self._room:GetPlayerBySeat(seat)
    self._cacheEvent:Enqueue(function()
        local  _room = self._room
        _room.last_outcard_seat = seat
        if seat == _room.self_player.seat and __pre_delete_card then
            __pre_delete_card = false
        else
            if seat == _room.self_player.seat then
                list_remove(p.card_list, card)
                table.sort(p.card_list, ViewUtil.HandCardSort2)
            end
            p.hand_left_count = p.hand_left_count - 1
            if not p.outcard_list then p.outcard_list = {} end
            p.outcard_list[#p.outcard_list+1] = card
            DispatchEvent(self._dispatcher,TX_GameEvent.OutCard, p, card)
        end
    end)
end


function M:OnEventTakeCard(evt_data)
	printlog("抓牌===========>>>")
	pt(evt_data)
	self._room.self_player.tingPaiList=evt_data.ting_list
	
	if evt_data.ting_list and #evt_data.ting_list>0 then
		local tempTingList={}
		local tempCardTingList={}
		for i=1,#DataManager.CurrenRoom.self_player.tingPaiList do
			local tempCard=DataManager.CurrenRoom.self_player.tingPaiList[i].card
			local tempV=DataManager.CurrenRoom.self_player.tingPaiList[i].value
			tempCardTingList[tempCard]=tempV
			if  tempV and #tempV>0 then
				for j=1,#tempV do
					if IsHasDictionary(tempV[j],tempTingList)==false then
						table.insert(tempTingList,tempV[j])
					end
				end
			end
		end
		if #tempTingList>0 then
			self._room.self_player.allTingPaiList=tempTingList
			self._room.self_player.CardTingList=tempCardTingList
			--pt(tempCardTingList)
		end
	end
	
    local _room = self._room
    local seat = evt_data["seat"]
    local card = evt_data["card"]
    local left_count = evt_data["left_count"]
    local p = _room:GetPlayerBySeat(seat)
    self._cacheEvent:Enqueue(function()
        p.hand_left_count = p.hand_left_count +1
        if (seat == _room.self_player.seat) then
            _room.self_player.card_list[#_room.self_player.card_list+1] = card
            -- table.sort( _room.self_player.card_list, ViewUtil.HandCardSort )
        end
        DispatchEvent(self._dispatcher,TX_GameEvent.GetCard, seat, card, left_count)
    end)
end

function M:OnEventOutHint(evt_data)
	printlog("出牌提示事件===========>>>")
	pt(evt_data)
    self._cacheEvent:Enqueue(function()
        self._room.curren_outcard_seat = self._room.self_player.seat
        DispatchEvent(self._dispatcher,TX_GameEvent.OutHint)
    end)
end

function M:OnEventTurn(evt_data)
	printlog("转轮指向===========>>>")
	pt(evt_data)
    local seat = evt_data["seat"]
    self._cacheEvent:Enqueue(function()
        -- self._room.curren_outcard_seat = seat
        DispatchEvent(self._dispatcher,TX_GameEvent.EventTurn, seat)
    end)
end

function M:OnEventFzTips(evt_data)
	printlog("放子提示事件===========>>>")
	pt(evt_data)
	
    self._cacheEvent:Enqueue(function()
		
		local tiplist = FZTipList.new()
        local list =  evt_data["tip_list"]
        for i=1,#list do
            local dtip =  list[i]
            local tip = {}
            tip.id = dtip["id"]
            tip.weight = dtip["weight"]
            tip.card = dtip["card"]
            tip.type = dtip["type"]
            tip.opcard = dtip["opcard"]
            tiplist:AddTip(tip)
        end
		DispatchEvent(self._dispatcher,TX_GameEvent.FZTips, tiplist)
    end)
end

function M:OnEventFzAction(evt_data)
	printlog("吃杠碰行为事件===========>>>")
	pt(evt_data)
	
	self._room.self_player.CardTingList={}
	self._room.self_player.allTingPaiList={}
	self._room.self_player.tingPaiList=evt_data.ting_list
	
	if evt_data.ting_list and #evt_data.ting_list>0 then
		local tempTingList={}
		local tempCardTingList={}
		for i=1,#DataManager.CurrenRoom.self_player.tingPaiList do
			local tempCard=DataManager.CurrenRoom.self_player.tingPaiList[i].card
			local tempV=DataManager.CurrenRoom.self_player.tingPaiList[i].value
			tempCardTingList[tempCard]=tempV
			if  tempV and #tempV>0 then
				for j=1,#tempV do
					if IsHasDictionary(tempV[j],tempTingList)==false then
						table.insert(tempTingList,tempV[j])
					end
				end
			end
		end
		if #tempTingList>0 then
			self._room.self_player.allTingPaiList=tempTingList
			self._room.self_player.CardTingList=tempCardTingList
			--pt(tempCardTingList)
		end
	end
	
	local _room = self._room
    local playerid = evt_data["playerid"]
    local card = evt_data["card"]
    local actice_card = evt_data["active_card"]
    local type = evt_data["type"]
    local from_seat = evt_data["from_seat"]
    local opcard = evt_data["opcard"]
    -- local openkong = evt_data["openkong"]

    local p = _room:GetPlayerById(playerid)
    self._cacheEvent:Enqueue(function()
        local fz = nil
        local index = -1
        local ftype = type
        if (ftype == FZType.Gang_Peng) then
        	for i=1,#p.fz_list do
                if (p.fz_list[i].card == card) then
                    p.fz_list[i].card = card
                    fz = p.fz_list[i]
                    fz.type = type
                    index = i -1
                    break
                end
            end
        end
        if (index == -1) then
            fz = {}
            fz.card = card
            fz.type = type
            fz.active_card = actice_card
            p.fz_list[#p.fz_list+1] = fz
        end
		
		fz.allCard={}
		if from_seat ~= p.seat then
			table.insert(fz.allCard,card)
			if opcard and #opcard>0 then
				for i=1,#opcard do
					table.insert(fz.allCard,opcard[i])
				end
			end
		else
			fz.allCard=opcard
		end
		
		printlog("吃杠碰显示牌=====>>>")
		pt(fz.allCard)
		
		fz.opcard=opcard
        fz.from_seat = from_seat
        local remove_num = #opcard

        if (p == _room.self_player) then
        	for i=1,remove_num do
        		list_remove(p.card_list,opcard[i])
        	end
        end

        p.hand_left_count = p.hand_left_count - remove_num
        if from_seat ~= p.seat then
            -- if (fz.Type == FZType.Chi) then card = actice_card end
            local fp = _room:GetPlayerBySeat(from_seat)
            table.remove(fp.outcard_list,#fp.outcard_list)    
        end

        DispatchEvent(self._dispatcher,TX_GameEvent.FangziAction, fz, p, index)
    end)
end

function M:OnEventHu(evt_data)
	printlog("胡牌===========>>>")
	pt(evt_data)
	
	local cards = evt_data["card"]
    local win_p = self._room:GetPlayerBySeat(evt_data["seat"])
    local lose_p = self._room:GetPlayerBySeat(evt_data["from_seat"])
    local win_card = evt_data["win_card"]
    local win_list = evt_data["win_list"]
    
    self._cacheEvent:Enqueue(function()
        win_p.card_list = cards
        table.sort( win_p.card_list, ViewUtil.HandCardSort2)
        DispatchEvent(self._dispatcher,TX_GameEvent.ZPHuCard, evt_data["seat"], evt_data["from_seat"], win_card, cards, win_list)
    end)
	
    --[[local cards = evt_data["card"]
    local win_p = self._room:GetPlayerBySeat(evt_data["seat"])
    local lose_p = self._room:GetPlayerBySeat(evt_data["from_seat"])
    local hu_card = evt_data["win_card"]    
    table.sort(cards, ViewUtil.HandCardSort)
    cards[#cards +1] = hu_card
    
    self._cacheEvent:Enqueue(function()
        win_p.card_list = cards
        DispatchEvent(self._dispatcher,TX_GameEvent.ZPHuCard, evt_data["seat"], evt_data["from_seat"], cards, hu_card)
    end)--]]
end

function M:OneventResult1(evt_data)
	printlog("小结算===========>>>")
	pt(evt_data)
    local over = evt_data.type
    --0：小结算   1：小大结算    2：大结算
    self._room._reload_flag = false
    self._room.playing = false
    if 0 == over then
        local result = evt_data.result
        self._cacheEvent:Enqueue(function()
            for i = 1, #self._room.player_list do
                local p = self._room.player_list[i]
                p.hand_left_count = 0
                p.outcard_list = {}
            end
            DispatchEvent(self._dispatcher,TX_GameEvent.ZPResult1, result);
        end)
    elseif 1 == over or 2 == over then
        DataManager.CurrenRoom.Over = true
        ControllerManager.SetGameNetClient(nil,true)
        local total_result = evt_data.total_result
        local result = evt_data.result
        self._cacheEvent:Enqueue(function()
            DispatchEvent(self._dispatcher,TX_GameEvent.ZPResult2, result, total_result, over);
        end)
    end
end

-- function M:OnEventResult2(evt_data)
--     DataManager.CurrenRoom.Over = true
--     ControllerManager.SetGameNetClient(nil,true)
    -- local info_list = evt_data["info_list"]
    -- if self._result ~= nil then
    --     self._cacheEvent:Enqueue(function()
    --         self:OneventResult1(self._result)
    --         self._result = nil
    --     end)
    -- end
--     self._cacheEvent:Enqueue(function()
--         DispatchEvent(self._dispatcher,TX_GameEvent.ZPResult2, info_list)
--     ControllerManager.ChangeController(LoddyController)
--     end)
-- end

function M:OnEventNiao(evt_data)
    local list = evt_data["niao"]
    local start_seat = evt_data["start_seat"]
    self._cacheEvent:Enqueue(function()
        DispatchEvent(self._dispatcher,TX_GameEvent.EventNiao, list, start_seat)
    end)
end

function M:OnEventPiaoTip()
    if ViewManager.GetCurrenView().dview_class == LobbyView then
        self:ReturnToRoom()
        return
    end

    self._cacheEvent:Enqueue(function()
        if not self._room._reload_flag then  
            self._room.curren_round = self._room.curren_round + 1
        end
        self._room.playing = true
        DispatchEvent(self._dispatcher,TX_GameEvent.EvnetPiaoTip, evt_data)
    end)
end

function M:OnEventPiao(evt_data)
    self._cacheEvent:Enqueue(function()
        DispatchEvent(self._dispatcher,TX_GameEvent.EvnetPiao, evt_data.seat, evt_data.num)
    end)
end

function M:GetPosString( seat )
    if DataManager.CurrenRoom.room_config.people_num ~= 4 then return"" end
	if seat == 1 then
		return "北"
	elseif seat == 2 then
		return "西"
	elseif seat == 3 then 
		return "南"
	elseif seat == 4 then
		return "东"
	end
end

function M:Discard(card)
	local _data = {}
    _data["card"] = card
    local _room = self._room
    local _client = ControllerManager.GameNetClinet 
    -- list_remove(_room.SelfPlayer.Cards,card)
    -- table.sort(_room.SelfPlayer.Cards)
    _client:send(Protocol.Game_Da, _data)
end

return M