FuliLimitPackageView = FuliLimitPackageView or BaseClass(BaseView)
local FuliLimitPackageView= FuliLimitPackageView
function FuliLimitPackageView:__init()
	self.base_file = "fuli"
	self.layout_file = "FuliLimitPackageView"
	self.layer_name = "Top"
	self.use_background = true
	
	self.click_bg_toClose = false
	self.change_scene_close = true
	self.destroy_imm = true
	self.is_set_zdepth = true
	self.limit_num = false	
	self.model = FuliModel:getInstance()
	self.mainVo = RoleManager.Instance.mainRoleInfo
	self.reward_item_list = {}
	self.num_item_list = {}
	self.item_list = {}
	self.list_item_animation = false
	
	self.open_callback = function()
		self:InitData()
	end

	self.load_callback = function()		
		self:LoadSuccess()
		self:InitEvent()
		self.model:Fire(FuliConst.REQ_FULI_SCMD, 16011)
	end

	self.close_callback = function ()
	end

	self.destroy_callback = function()
		self:Remove()
	end
	self.ReOpen_callback = function ()
	end	
end

function FuliLimitPackageView:Open()
	BaseView.Open(self)
	GlobalEventSystem:Fire(SceneEventType.CLOSE_DIALOGUE_VIEW)
	GlobalEventSystem:Fire(EventName.STOP_AUTO_DO_TASK)
	GlobalEventSystem:Fire(EventName.STOPAUTOFIGHT)	

end

function FuliLimitPackageView:Remove()

	for i,item in pairs(self.reward_item_list) do
		item:ReleaseObj()
	end	
	self.reward_item_list = {}

	for i,item in pairs(self.item_list) do
		item:DeleteMe()
	end
	self.item_list = {}	

	for i,item in pairs(self.num_item_list) do
		item:DeleteMe()
	end
	self.num_item_list = {}	

	if self.is_do_action then
		MainUIController.Instance.MainRoleHeadInfoView:SetLimitPackageBtnVisible(true)	
	end

	if self.tween_id then
		TweenLite.Stop(self.tween_id)
		self.tween_id = nil
	end	

    --完成引导
    local helpVo = GuideModel:getInstance():GetHelpVo(HelpType.TYPE_LIMIT_PACKAGE,2) 
    if helpVo then
        GlobalEventSystem:Fire(EventName.FINISH_CURRENT_HELP_STEP,helpVo)
        GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK)
        GlobalEventSystem:Fire(EventName.START_AUTO_DO_TASK)
    end 	

    if self.timer_countdown then
        TimerQuest.CancelQuest(GlobalTimerQuest, self.timer_countdown)
        self.timer_countdown = nil
    end    

    self:StopAnimationList()
end

function FuliLimitPackageView:LoadSuccess()
	
	local nodes = { 
		"center/title_text:txt", 
		"center/close:obj",
		"center/bg1:raw", 
		"center/count_text:txt", 
		"center/bg:raw", 
		"center/bg2:raw", 
		"center/continue:obj:img", 
		"center/reward_scroll", 
		"center/reward_scroll/Viewport/reward_con", 
		"center/icon:img:obj", 
		"center/item_scroll/Viewport/item_con", 
		"center/item_scroll", 
		"icon_cont:obj",
		"center/time_text:txt", 
		"center:obj",
		"center/num_ani_con", 
	}

	self:GetChildren(nodes)	

	lua_resM:setOutsideRawImage(self, self.bg_raw, GameResPath.GetViewBigBg("fuli_limit_package_bg1_1102_605"),false)
	lua_resM:setOutsideRawImage(self, self.bg1_raw, GameResPath.GetFuliImage("fuli_limit_package_text_1"),false)
	lua_resM:setOutsideRawImage(self, self.bg2_raw, GameResPath.GetFuliImage("fuli_limit_package_text_2"),false)

	self:InitEvent()
end

function FuliLimitPackageView:InitEvent()	
	local function onBtnClickHandler(target)
		if target == self.close_obj then
			self:Continue()
		elseif target == self.continue_obj then
			self:Continue()
		end
	end	
	AddClickEvent(self.close_obj,onBtnClickHandler)
	AddClickEvent(self.continue_obj,onBtnClickHandler)

	local function on_fuli_limit_update()
		self:UpdateInfo()
	end
	self:BindEvent(FuliModel:getInstance(), FuliConst.FULI_LIMIT_INFO_UPDATE, on_fuli_limit_update)
end


function FuliLimitPackageView:InitData()
	self.cfg = DeepCopy(self.model:GetFuliLevelCFG(self.mainVo.career))
	if not self.cfg or not self.cfg[1] then
		return
	end

	local b = TaskModel:getInstance():IsTaskFinished(FuliConst.LIMIT_PACKAGE_TASK.CLOSE_TASK_ID)	
	lua_resM:setImageSprite(self, self.continue_img,"fuli_asset",b and "fuli_item34" or "fuli_item29")
	self.limit_num = self.cfg[1].limit_num
	self.title_text_txt.text = string.format("%s ", HtmlColorTxt( self.cfg[1].worth, "#ffd633"))   
	local reward_list = self.cfg[1].award_limit_list

	if #reward_list > 0 then
		for i,v in ipairs(reward_list) do
			local item = self.reward_item_list[i]
			if item == nil then 
				item = UIObjPool:getInstance():PopItem(UIObjPool.UIType.AwardItem, self.reward_con)
				self.reward_item_list[i] = item
			end			
			if v.is_limit then
				item:SetNumLimitVisible( true, 4 )
				item:SetData(v[2], 1, nil, nil)
			else
				item:SetNumLimitVisible( false )
				item:SetData(v[2], v[3], nil, nil)
			end	             
			item:SetItemSize(50, 50)
			item:SetAnchoredPosition((i - 1) * 65 + 7.5,-8)    
		end
		for i=#reward_list + 1,#self.reward_item_list do
			self.reward_item_list[i]:SetVisible(false)
		end
	end	
	SetSizeDeltaX(self.reward_con, 65 * #reward_list)	

	local helpVo = GuideModel:getInstance():GetHelpVo(HelpType.TYPE_LIMIT_PACKAGE,2)   
	if helpVo then
		self:CheckLeftTime()
	end
end

function FuliLimitPackageView:UpdateInfo()
	self.data = self.model.fuli_limit_package_info
	if self.data then
		if not self.limit_num then
			self.cfg = DeepCopy(self.model:GetFuliLevelCFG(self.mainVo.career))
			if not self.cfg or not self.cfg[1] then
				return
			end
			self.limit_num = self.cfg[1].limit_num
		end
		local num = self.limit_num - self.data.number
		if num < FuliConst.LIMIT_PACKAGE_CONST.LIMIT_NUM then
			num = FuliConst.LIMIT_PACKAGE_CONST.LIMIT_NUM
		end
		self.count_text_txt.text = string.format("/%d", self.limit_num)   		
		local t_num = 10000
		local t_num_list = {}
		local num_list = {}
		for i=1,5 do
			local m = num / t_num
			local n = num % t_num
			t_num_list[i] = math.floor(m)
			num = n
			t_num = t_num / 10			
		end

		for i,v in ipairs(t_num_list) do
			if v ~= 0 then
				for ii=i,#t_num_list do
					table.insert(num_list, t_num_list[ii])					
				end
				break
			end
		end
		for i,v in ipairs(num_list) do
			local item = self.num_item_list[i]
			if item == nil then 
				item = FuliLimitPackageNumItem.New(self.num_ani_con,nil)
				self.num_item_list[i] = item
			end
			item:SetData(v, 0.5 * i, i)	
			item:SetAnchoredPosition(85-(#num_list - i)*12, -8)
		end

		local packag_name = self.cfg[1].name or "至尊级限量礼包"

		local function LoadSuccessCallBack( )
			self.load_item_idx = self.load_item_idx - 1
			if self.load_item_idx == 0 then
				self:ResetPlayerInfo(packag_name)
			end
		end

		local list = self.data.list 
		self.load_item_idx = #list
		if #list > 0 then
			for i,v in ipairs(list) do
				local item = self.item_list[i]
				if item == nil then 
					item = FuliLimitPackageItem.New(self.item_con,nil)
					self.item_list[i] = item
				end			
				item:SetLoadCallBack(LoadSuccessCallBack)
			end
		end			
	end
end

function FuliLimitPackageView:ResetPlayerInfo(packag_name)
	self.list_item_animation = {}
	local total_w = 0
	local scroll_width = GetSizeDeltaX(self.item_scroll)
	for i= 1,#self.item_list do
		local item = self.item_list[i]
		if item then
			local d = self.data.list[i]
			self.list_item_animation[i] = self.list_item_animation[i] or {}
			d.packag_name = packag_name			
			item:SetData(d)			
			item:SetAnchoredPosition(scroll_width + total_w,0)    
			local w = item:GetWidth()			
			self.list_item_animation[i].item = item 
			self.list_item_animation[i].width = w			
			total_w = total_w + w
		end
	end
	self.anim_end_pos = scroll_width
	SetSizeDeltaX(self.item_con, total_w)
	self:StartAnimationList()
end

function FuliLimitPackageView:InitActoin()
	self.image_obj = UiFactory.createChild(self.icon_cont, UIType.ImageExtend)
	self.image_obj.transform.sizeDelta = Vector2(72, 72)
	self.image_icon = self.image_obj:GetComponent("ImageExtend")
	SetLocalPosition(self.image_obj.transform, 0, 0, 0)
	lua_resM:setImageSprite(self, self.image_icon, "mainUI_asset", "limit_package_btn_bg", true)
	
end

--动画开始
function FuliLimitPackageView:PlayAction( )
	local callback = function()
		MainUIController.Instance.MainRoleHeadInfoView:SetLimitPackageBtnVisible(true)		
		self:Close()
	end
	self.is_do_action = true
	local pos = MainUIController.Instance.MainRoleHeadInfoView:GetLimitPackageBtnPos()
	if pos and self.image_obj then
		MainUIController.Instance.MainRoleHeadInfoView:SetLimitPackageBtnVisible(false)		
		self.center_obj:SetActive(false)
		self.icon_cont_obj:SetActive(true)
		self.tween_id = TweenLite.to(self, self.image_obj.transform, TweenLite.UiAnimationType.POS, pos, 0.8, callback)
	else
		callback()
	end
end

function FuliLimitPackageView:Continue()
	if TaskModel:getInstance():IsTaskFinished(FuliConst.LIMIT_PACKAGE_TASK.CLOSE_TASK_ID) then
		self.model:Fire(FuliConst.REQ_FULI_SCMD, 16006, self.cfg[1].id)
		self:Close()
	else		
    	local helpVo = GuideModel:getInstance():GetHelpVo(HelpType.TYPE_LIMIT_PACKAGE,2)   
    	if helpVo then
			self:InitActoin()
			self:PlayAction()	
		else
			self:Close()
			GlobalEventSystem:Fire(EventName.START_AUTO_DO_TASK)
			GlobalEventSystem:Fire(EventName.FORCE_TO_DO_TASK)	
		end    		
	end	
end

function FuliLimitPackageView:CheckLeftTime()
    if self.timer_countdown then
        TimerQuest.CancelQuest(GlobalTimerQuest, self.timer_countdown)
        self.timer_countdown = nil
    end
    local leftTime = 15
    local function timer_func()
        leftTime = leftTime - 1
        if leftTime <= 0 then
            self:Continue()
        else
            self.time_text_txt.text = string.format("%s 秒后自动关闭界面", HtmlColorTxt( leftTime, "#0CE148") )
        end
    end
    self.timer_countdown = TimerQuest.AddPeriodQuest(GlobalTimerQuest, timer_func, 1)       
    timer_func()
end


function FuliLimitPackageView:StopAnimationList()
    if self.timer_anim_list then
        TimerQuest.CancelQuest(GlobalTimerQuest, self.timer_anim_list)
        self.timer_anim_list = nil
    end
end

function FuliLimitPackageView:StartAnimationList()
	if self.list_item_animation then
	    local function timer_func()	    	
	    	local end_pos_x = self.anim_end_pos
	    	for i,v in ipairs(self.list_item_animation) do
	    		local cur_pos_x = v.cur_pos_x 
	    		if not cur_pos_x then
	    			local pos = v.item:GetAnchoredPosition()
	    			cur_pos_x = pos.x
	    		end 
	    		cur_pos_x = cur_pos_x- 3	
	    		v.cur_pos_x = cur_pos_x    	
	    		v.item:SetAnchoredPosition(cur_pos_x, 0)	    	
	    		end_pos_x = end_pos_x < cur_pos_x + v.width and cur_pos_x + v.width or end_pos_x
	    	end
	    	for i,v in ipairs(self.list_item_animation) do
	    		if v.cur_pos_x < - v.width  then
	    			v.item:SetAnchoredPosition(end_pos_x, 0)
	    			v.cur_pos_x = end_pos_x
	    		end
	    	end
	    end
	    self.timer_anim_list = TimerQuest.AddPeriodQuest(GlobalTimerQuest, timer_func, 0.02)       
	    timer_func()
	end	
end