local UIGuildMember = UIViewClass()

local ViewState = 
{
    Members = 1,
    KickMembers = 2,
    ApprovalMembers = 3,
}

local SortState = 
{
    Job = 0,
    Level = 1,
    GS = 2,
    Today = 3,
    SevenDays = 4,  
    Online = 5,
}


function UIGuildMember:OnOpened(context)
    self:RegistSystemEvent(EventID.UI_Guild_GuildInfoRefresh, self.ShowInfo)
    self:RegistSystemEvent(EventID.UI_Guild_KickOutRefresh, self.ClearKickList)
    self.viewState = ViewState.Members
    self:ShowInfo(MDL.Guild.GetGuildMemberInfo())
    if not MDL.Guild.JobHasPermission(MDL.Guild.GetMyGuildInfo().jobTitle,MDL.Guild.AuthorityEnum.GuildInvite) then
        self.toggle_TopGroup:SetToggleActive(2, false)
    else
        self:RegistSystemEvent(CTL.RedPoint.RedPointKey.Guild_Member_Approval, self.RefreshGuildRedpoint)
        self:RefreshGuildRedpoint(CTL.RedPoint.GetRedPointActive(CTL.RedPoint.RedPointKey.Guild_Member_Approval))
    end
    self:RegistSystemEvent(CTL.RedPoint.RedPointKey.Guild_Member_RedPacket, self.RefreshGuildRedPacketRedpoint)
    self:RefreshGuildRedPacketRedpoint(CTL.RedPoint.GetRedPointActive(CTL.RedPoint.RedPointKey.Guild_Member_RedPacket))
    self.IsReverseSort = false
end

function UIGuildMember:RefreshGuildRedpoint(active)
    self.toggle_TopGroup:SetRedPoint(1, active)
end

function UIGuildMember:RefreshGuildRedPacketRedpoint(active)
    if active == nil then
        UIUtils.SetActive(self.img_RedPacketRedpoint, false)
    else
        UIUtils.SetActive(self.img_RedPacketRedpoint, active)
    end
end

function UIGuildMember:ShowInfo(data)
    self.myGuildInfo = data
    self:RefershBtns()
    UIUtils.SetLabelText(self.txt_Top8, Const_IDS.IDS_Guild_ListTitle8)
    self.txt_Number.text = string.FormatByIdsId(Const_IDS.IDS_GuildMainpage_Label12,  MDL.Guild.GetOnlineCount(self.myGuildInfo.members),
    self.myGuildInfo.listInfo.memberCount, self.myGuildInfo.listInfo.memberCountLimit)
end


function UIGuildMember:OnButtonClicked(comp)
    if comp == self.event_QuitGuild then
        CTL.GuildEscort.GuildEscortQuit(function()
            local labelIDS = Const_IDS.IDS_GuildQuitConfirm_Label
            if CTL.WarZone.IsWarZoneOpen() then
                labelIDS = Const_IDS.IDS_GuildQuitConfirm_Label2
            end
            UTL.MessageBox.ShowOKCancelBox(Const_IDS.IDS_GuildQuitConfirm_Title, labelIDS, function ()
                MDL.Guild.GuildLeaveReq(self.myGuildInfo.listInfo.id)
            end, nil)
        end)
    elseif comp == self.btn_CloseInput then
        if self.search then
            self.search = false
            self.loopScroll_Guild_Normal:ReloadAll(self.myGuildInfo.members)
        end
        self.obj_InputField.text = nil
    elseif comp == self.btn_Search then
        self:SearchGuild()
    elseif comp == self.btn_QuickKick then
        self.viewState = ViewState.KickMembers
        self.kickList = {}
        self:RefershBtns()
    elseif comp == self.btn_Cancel then
        self.viewState = ViewState.Members
        self.kickList = {}
        self:RefershBtns()
    elseif comp == self.btn_Sure then
        if #self.kickList == 0 then
            CTL.Sound.PlayGameSound("UI_invalid")
            CTL.Tips.AddTipsMsg(Const_IDS.IDS_GuildApply_QuickKickNoTarget)
        else
            UIManager.OpenView(Const_UI_Lua.UIEnum.UIGuildMemberKickOut, self.kickList)
        end
    elseif self.btn_GuildList == comp then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIGuildGuildListPanel)
        
    elseif self.btn_RefuseAll == comp then
        self:ApprovalAll(false)
    elseif self.btn_AcceptAll == comp then
        self:ApprovalAll(true)
    elseif comp == self.btn_Arrow_Level then
        if self.curSortState == SortState.Level then
            table.reverseTable(self.curMembers)
            self:SetArrow(2,true)
        else
            MDL.Guild.SortByLevel(self.curMembers)
            self:SetArrow(2,false)
        end
        self.curSortState = SortState.Level
        self.loopScroll_Guild_Normal:ReloadAll(self.curMembers)
        self.IsReverseSort = not self.IsReverseSort
    elseif comp == self.btn_Arrow_CE then
        if self.curSortState == SortState.GS then
            if self.IsReverseSort then
                MDL.Guild.SortByGS(self.curMembers)
                table.reverseTable(self.curMembers)
            else
                MDL.Guild.SortByGS(self.curMembers)
            end
            self:SetArrow(3,true)
        else
            MDL.Guild.SortByGS(self.curMembers)
            self:SetArrow(3,false)
        end
        self.curSortState = SortState.GS
        self.loopScroll_Guild_Normal:ReloadAll(self.curMembers)
        self.IsReverseSort = not self.IsReverseSort
    elseif comp == self.btn_Arrow_JR then
        if self.curSortState == SortState.Today then
            if self.IsReverseSort then
                MDL.Guild.SortByToday(self.curMembers)
                table.reverseTable(self.curMembers)
            else
                MDL.Guild.SortByToday(self.curMembers)
            end
            self:SetArrow(4,true)
        else
            MDL.Guild.SortByToday(self.curMembers)
            self:SetArrow(4,false)
        end
        self.curSortState = SortState.Today
        self.loopScroll_Guild_Normal:ReloadAll(self.curMembers)
        self.IsReverseSort = not self.IsReverseSort
    elseif comp == self.btn_Arrow_QR then
        if self.curSortState == SortState.SevenDays then
            if self.IsReverseSort then
                MDL.Guild.SortBy7Day(self.curMembers)
                table.reverseTable(self.curMembers)
            else
                MDL.Guild.SortBy7Day(self.curMembers)
            end
            self:SetArrow(5,true)
        else
            MDL.Guild.SortBy7Day(self.curMembers)
            self:SetArrow(5,false)
        end
        self.curSortState = SortState.SevenDays
        self.loopScroll_Guild_Normal:ReloadAll(self.curMembers)
        self.IsReverseSort = not self.IsReverseSort
    elseif comp == self.btn_Arrow_Job then
        if self.curSortState == SortState.Job then
            if self.IsReverseSort then
                MDL.Guild.SortByJob(self.curMembers)
                table.reverseTable(self.curMembers)
            else
                MDL.Guild.SortByJob(self.curMembers)
            end
            self:SetArrow(1,true)
        else
            MDL.Guild.SortByJob(self.curMembers)
            self:SetArrow(1,false)
        end
        self.curSortState = SortState.Job
        self.loopScroll_Guild_Normal:ReloadAll(self.curMembers)
        self.IsReverseSort = not self.IsReverseSort
    elseif comp == self.btn_Arrow_Online then
        if self.curSortState == SortState.Online then
            if self.IsReverseSort then
                MDL.Guild.SortByOnline(self.curMembers)
                table.reverseTable(self.curMembers)
            else
                MDL.Guild.SortByOnline(self.curMembers)
            end
            self:SetArrow(6,true)
        else
            MDL.Guild.SortByOnline(self.curMembers)
            self:SetArrow(6,false)
        end
        self.curSortState = SortState.Online
        self.loopScroll_Guild_Normal:ReloadAll(self.curMembers)
        self.IsReverseSort = not self.IsReverseSort
    elseif comp == self.btn_JoinInLimit then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIGuildJoinInPanel,self.myGuildInfo)
    elseif comp == self.btn_AutoAccept then
        if not MDL.Guild.JobHasPermission(MDL.Guild.GetMyGuildInfo().jobTitle,MDL.Guild.AuthorityEnum.GuildInvite) then
            CTL.Sound.PlayGameSound("UI_invalid")
            CTL.Tips.AddTipsMsg(Const_IDS.IDS_Guild_CommonFail4)
        else
            MDL.Guild.GuildSetupReq(MDL.Guild.GuildUpdateType.IsAutoApprove,tostring(not self.myGuildInfo.listInfo.isAutoApprove))
        end
    elseif comp == self.event_GuildRedPacket then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIRedPacketMain)
    end
end

function UIGuildMember:ApprovalAll( approval )
    if #self.myGuildInfo.approvalList == 0 then
        CTL.Sound.PlayGameSound("UI_invalid")
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_GuildApply_Empty)
    else
        local list = {}
        for i,v in ipairs(self.myGuildInfo.approvalList) do
            table.insert( list, v.roleInfo.acid)
        end
        if approval then
            MDL.Guild.GuildApprovalReq(list,nil,true)
        else
            MDL.Guild.GuildApprovalReq(nil,list,true)
        end
    end
end

function UIGuildMember:ReloadMembers()
    self.loopScroll_Guild_Normal:ReloadAll(self.myGuildInfo.members)
end

function UIGuildMember:RefershBtns()
    if self.viewState == ViewState.Members then
        self.group_MemberList_KickOut.gameObject:SetActive(false)
        self.group_MemberList.gameObject:SetActive(true)
        self.group_ApplyList.gameObject:SetActive(false)
        if self.loopScroll_Guild_Normal.Count == 0 then
            for i,v in ipairs(self.myGuildInfo.members) do
                self.loopScroll_Guild_Normal:AddData(v,0)
            end
        else
            if self.curSortState == nil then
                self:StartRepeatFunc(self.ReloadMembers, 1, 1)
            end
        end
        self.curMembers = self.myGuildInfo.members
        if GameAppInfo.IsChinesePackage() then
            --国服包去掉【批量请离】入口
            UIUtils.SetActive(self.btn_QuickKick, false)
        else
            local kick = MDL.Guild.JobHasPermission(MDL.Guild.GetMyGuildInfo().jobTitle,MDL.Guild.AuthorityEnum.GuildKick)
            UIUtils.SetActive(self.btn_QuickKick, kick)
        end
    elseif self.viewState == ViewState.KickMembers then
        self.group_MemberList_KickOut.gameObject:SetActive(true)
        self.group_MemberList.gameObject:SetActive(false)
        self.group_ApplyList.gameObject:SetActive(false)
        local kick = MDL.Guild.JobHasPermission(MDL.Guild.GetMyGuildInfo().jobTitle,MDL.Guild.AuthorityEnum.GuildKick)
        if not kick then
            self.kickList = {}
        end
        if self.loopScroll_Guild_KickOut.Count == 0 then
            for i,v in ipairs(self.myGuildInfo.members) do
                self.loopScroll_Guild_KickOut:AddData(v,0)
            end
        else
            self.loopScroll_Guild_KickOut:ReloadAll(self.myGuildInfo.members)
            self:RemoveKickList()
        end
    elseif self.viewState == ViewState.ApprovalMembers then
        self.group_MemberList_KickOut.gameObject:SetActive(false)
        self.group_MemberList.gameObject:SetActive(false)
        self.group_ApplyList.gameObject:SetActive(true)
        if self.loopScroll_Guild_ApplyList.Count == 0 then
            for i,v in ipairs(self.myGuildInfo.approvalList) do
                self.loopScroll_Guild_ApplyList:AddData(v,0)
            end
        else
            self.loopScroll_Guild_ApplyList:ReloadAll(self.myGuildInfo.approvalList)
        end
        if self.loopScroll_Guild_ApplyList.Count == 0 then
            self.group_Empty_Apply.gameObject:SetActive(true)
        else
            self.group_Empty_Apply.gameObject:SetActive(false)
        end    
        self.autoAccept_Checkmark.gameObject:SetActive(self.myGuildInfo.listInfo.isAutoApprove)
    end
end

function UIGuildMember:OnValueChanged(comp, value)
    if comp == self.obj_InputField then
        if string.isNilOrEmpty(self.obj_InputField.text) then
            if self.search  then
                self.search = false
                self.loopScroll_Guild_Normal:ReloadAll(self.myGuildInfo.members)
            end
        end
        UIUtils.SetActive(self.btn_CloseInput, not string.isNilOrEmpty(self.obj_InputField.text))
    elseif comp == self.toggle_TopGroup then
        local list = {}
        if value == 0 then
            self.viewState = ViewState.Members
            self:RefershBtns()
        else
            self.viewState = ViewState.ApprovalMembers
            self:RefershBtns()
        end
    end
end

function UIGuildMember:SetArrow(index,reverse)
    if reverse then
        local x,y,z =  self.arrows[index].transform:GetLocalScale()
        self.arrows[index].transform:SetLocalScale(x,-y,z)
    else
        for i,v in ipairs(self.arrows) do
            if i == index then
                self.arrows[i].transform:SetLocalScale(1,1,1)
                self.arrows[i].gameObject:SetActive(true)
            else
                self.arrows[i].gameObject:SetActive(false)
            end
        end
    end
end

function UIGuildMember:OnCellInit(scrollRect, index, cellTable, data)
    local isMe = data.roleInfo.acid == BattleDataGetter.GetAcID()

    UIUtils.SetActive(cellTable.sprite_Me, isMe)
    UIUtils.SetActive(cellTable.sprite_Bg1, index % 2 ~= 0)
    CTL.Character.SetPortraitAndFrame(
            cellTable.UIHeroHead150, 
            data.roleInfo.PortraitId,
            data.roleInfo.FrameId
    )
    
    --势力成员等级列显示
    cellTable.Image.text = UTL.Item.GetNobilityByTeamLevel(data.roleInfo.level)
    
    CTL.Player.OperateGenderImage(cellTable.group_Gender, data.roleInfo.sex)
    cellTable.lab_HeroName.text = data.roleInfo.name
    
    cellTable.txt_CEPresent.text = data.roleInfo.gsSum
    if scrollRect == self.loopScroll_Guild_ApplyList then
        cellTable.txt_Top5_Info.text = data.approveTagline
    else
        local jobData = DataSheetManager.GuildJob:GetDataByID(data.jobTitle)
        cellTable.txt_Job.text = MDL.Guild.GetMemberJobDesc(data)
        cellTable.txt_Contribution_1.text = data.fameContributeToday
        cellTable.txt_Contribution_7.text = data.fameContribute7DaySum
        if data.roleInfo.isOnline then
            cellTable.txt_Online.text = UTL.Color.FormatGreenColor(UIUtils.GetLocalizedTxt(Const_IDS.IDS_Friend_Online))
        else
            local timeOffset = UTL.Time.GetServerTimestamp() - data.roleInfo.logoutTime
            cellTable.txt_Online.text = UTL.Color.FormatWhiteColor(UTL.Time.GetBeyondTime(timeOffset))
        end

        if scrollRect == self.loopScroll_Guild_KickOut then
            local myJobData =  DataSheetManager.GuildJob:GetDataByID(MDL.Guild.GetMyGuildInfo().jobTitle)
            if isMe then
                cellTable.toggle_KickSelect.gameObject:SetActive(false)
            elseif myJobData.Level <= jobData.Level then
                cellTable.toggle_KickSelect.gameObject:SetActive(false)
            else
                cellTable.toggle_KickSelect.isOn = table.containValue(self.kickList,data)
                cellTable.toggle_KickSelect.gameObject:SetActive(true)
            end
        elseif scrollRect == self.loopScroll_Guild_Normal then
            UIUtils.SetActive(cellTable.img_RedPacket, false)
            UIUtils.SetCanvasSortingOrderByMainCanvas(cellTable.UIHeroHead150.effectUpCanvas, cellTable.UpCanvas, CTL.Character.UpOrder.Common)
        end
    end
end

function UIGuildMember:OnCellClicked(scrollRect, index, cellTable, target, data)
    if scrollRect == self.loopScroll_Guild_ApplyList then
        if target == cellTable.btn_Accept then
            MDL.Guild.GuildApprovalReq({data.roleInfo.acid},nil)
        elseif target == cellTable.btn_Refuse then
            MDL.Guild.GuildApprovalReq(nil,{data.roleInfo.acid})
        end
    else
        if scrollRect == self.loopScroll_Guild_Normal and target == cellTable.img_RedPacket then
            UIManager.OpenView(Const_UI_Lua.UIEnum.UIRedPacketInfo, {redPacketConfigId = data.redEnvelopeBriefInfo.CfgID, roleInfo = data.roleInfo})
        else
            CTL.PlayerInteract.OpenFriendInteractView(data.roleInfo.acid, MDL.PlayerInteract.OccasionType.GuildMemberView)
        end
    end
end

function UIGuildMember:OnCellValueChanged(scrollRect, index, cellTable, target, value)
    if cellTable.toggle_KickSelect == target then
        local data = self.myGuildInfo.members[index+1]
        if value then
            if not table.containValue(self.kickList,data) then
                if #self.kickList== 10 then
                    cellTable.toggle_KickSelect.isOn = false
                    CTL.Tips.AddTipsMsg(Const_IDS.IDS_Guild_QuickKickNumLimitTip)
                else
                    table.insert(self.kickList, data)
                end
            end
        else
            table.removebyvalue(self.kickList, data)
        end
    end
end


function UIGuildMember:SearchGuild()
    if string.isNilOrEmpty(self.obj_InputField.text) then
        CTL.Sound.PlayGameSound("UI_invalid")
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_Chat_CantBlank)
        return 
    end
    local searchRes = {}
    for i,v in ipairs(self.myGuildInfo.members) do
        if string.find(v.roleInfo.name ,self.obj_InputField.text,1,true) then
            table.insert( searchRes, v)
        end
    end
    if #searchRes> 0 then
        self.search = true
        self.loopScroll_Guild_Normal:ReloadAll(searchRes)
        self.loopScroll_Guild_Normal:SelectIndex(0)
    else
        CTL.Sound.PlayGameSound("UI_invalid")
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_GuildSearch_Fail2)
    end
end

function UIGuildMember:ClearKickList()
    self.kickList = {}
end

function UIGuildMember:RemoveKickList()
    for _,member in ipairs(self.myGuildInfo.members) do
        for i,v in ipairs(self.kickList) do
            local isExits = false
            if  v.roleInfo.acid  == member.roleInfo.acid then 
                isExits = true
            end
            if not isExits then
                table.remove( self.kickList, i)
                break
            end
        end
    end
end

return UIGuildMember