'use strict';

import ReactNative from 'react-native';
import CategoryBService from '../../services/CategoryBService';
import Immutable, {Map} from 'immutable';
const {
	SET_TYPE,
	SET_DELAY_EXPOSE_DATA,

    GET_CATEGORY_B_LIST_REQUEST,
    GET_CATEGORY_B_LIST_SUCCESS,
    GET_CATEGORY_B_LIST_FAILURE,

    GET_CATEGORY_B_SUBDETAIL_REQUEST,
    GET_CATEGORY_B_SUBDETAIL_SUCCESS,
    GET_CATEGORY_B_SUBDETAIL_FAILURE,

	SET_CURRENT_CATEGORY_B,
	SET_CURRENT_CHANNEL_B,

	SET_CURRENT_CATEGORY_B_SUBDETAIL_FROM_CACHE,

	JUMP_TO_CATEGORY,

} = require('../../constants/actionTypes').default;


export function setDelayExposeData(delayExposeData) {
	return {
		type: SET_DELAY_EXPOSE_DATA,
		payload: delayExposeData,
	}
}

export function getCategoryBList() {
	return (dispatch, getState) => {
		let {app, categoryB} = getState();

		dispatch(getCategoryBListRequest());

		return new CategoryBService(app.host).getCategoryBList()
	        .then(json => {
				dispatch(getCategoryBListSuccess(json));

				dispatch(getCategoryBFirstSubCategoryDetail(categoryB.currentChannelId));
			})
			.catch(error => {
				dispatch(getCategoryBListFailure(error));
			});
	};
}

/**
 *  点击More事件
 **/
export function pressCategoryBMore(category_id){
	return (dispatch, getState) => {
		let {categoryB} = getState();

		//获取当前频道下一级分类列表信息
		let categoryData = categoryB.categoryList ? categoryB.categoryList.get(categoryB.currentChannelValue) : [];

		//获取指定category_id分类信息
		let category = null;
		categoryData.map((item, i) => {
			if(item && (category_id == item.get('category_id'))){
				category = item;
			}
		});

    	let all = {
            category_name: "全部" + (category ? category.get('category_name') : ""),
            parent_id: category_id + '',
            relation_parameter: category ? category.get('relation_parameter').toJS() : {},
            node_count: category ? category.get('node_count') : 0,
        };

        //设置当前的类别信息
    	// dispatch(setCurrentCateB(category_id, category ? category.get('category_name') : ""));
        dispatch(jumpToCategory(all, 0, categoryB.currentChannelId));

	};
}

export function fetchSubCategory(categoryId, categoryValue, callback) {
	return (dispatch, getState) => {
		let {
			categoryB
		} = getState();

		let {
            currentChannelId,
            currentCateId,
            currentCateValue,
            cacheSubCateData,
            delayExposeData,
        } = categoryB;

		//检查缓存是否存在数据，如果不存在则获取
	    let key = getSubDetailCacheKey(currentChannelId, categoryId);
	    let categoryData = cacheSubCateData ? cacheSubCateData.get(key) : "";
	    //已命中，展示缓存数据
	    if (categoryData) {
	        dispatch(getCategoryBSubDetailFromCache(categoryData));
	        //曝光从缓存获取的数据
	        if (delayExposeData) {

	        } else {
	        	//曝光从缓存获取的数据
	        	dispatch(dataExposure(currentChannelId, categoryId, categoryValue, categoryData));
	        }
	    //未命中，访问网络数据
	    } else {
	    	callback && callback();
	    }
	};
}

/**
 * 获取子分类的数据，逻辑上先判断缓存数据是否存在，不存在则从网络获取
 **/
export function getCategoryBSubCategoryDetail(categoryId, categoryValue){

	return (dispatch, getState) => {

		let {categoryB} = getState();

		let {
			currentChannelId,
            currentCateId,
            currentCateValue,
            cacheSubCateData,
			contentError,
        } = categoryB;

        //检查缓存是否存在数据
	    let key = getSubDetailCacheKey(currentChannelId, categoryId);
	    let categoryData = cacheSubCateData ? cacheSubCateData.get(key) : "";
	    //已有缓存
	    if (categoryData && categoryData.size > 0) {
	    	let lastTimestamp = categoryData.get('lrts', 0);
	    	let currentTimestamp = new Date().getTime();
	    	let diff = currentTimestamp - lastTimestamp;
	    	if (diff < 400) {
	    		__DEV__ && console.log('timestamp diff < 50, return');
	    		return;
	    	}
	    }

		if (contentError) {
			let lastTimestamp = contentError.lrts;
	    	let currentTimestamp = new Date().getTime();
	    	let diff = currentTimestamp - lastTimestamp;
	    	if (diff < 400) {
	    		__DEV__ && console.log('timestamp diff < 50, return');
	    		return;
	    	}
		}
		if (currentCateId == categoryId && categoryB.contentFetching) {
			return;
		}
        dispatch(getCategoryBSubDetail(currentChannelId, categoryId, categoryValue));
	};
}

/**
 *	获取子分类的KEY值
 **/
function getSubDetailCacheKey(channel_id, category_id){
	let key = "CHA_" + channel_id + "_CAT_" + category_id;
	return key;
}


/**
 * 网络获取子分类的数据
 **/
export function getCategoryBSubDetail(channel_id, category_id, category_value) {
	return (dispatch, getState) => {
		let {app, categoryB} = getState();

		if (categoryB.contentFetching) {
			return;
		}

		//各频道固定资源位
		let content_code = '';
		if(channel_id == '1'){
			content_code = 'daaa8b1a5103a30419ebd79c06e6feac';
		}
		else if(channel_id == '2'){
			content_code = '1a18449fa785631b302dc6d27388bf93';
		}
		else if(channel_id == '3'){
			content_code = '591152bee9fddcb0b4f793aa38304cb5';
		}
		else if(channel_id == '4'){
			content_code = 'e823582db5ead63c82e0d348c4e6a6bb';
		}

		dispatch(getCategoryBSubDetailRequest());

		return new CategoryBService(app.host).getCategoryBSubDetail(channel_id, category_id, content_code)
        .then(json => {
        	let payload = parseCategoryBSubDetail(channel_id, category_id, json, categoryB);
			dispatch(getCategoryBSubDetailSuccess(payload));
			if (categoryB.delayExposeData) {

	        } else {
	        	//曝光从网络获取的数据
				dispatch(dataExposure(channel_id, category_id, category_value, json));
	        }

		})
		.catch(error => {
			error.lrts = new Date().getTime();
			dispatch(getCategoryBSubDetailFailure(error));
		});
	};
}

/**
 *获取指定channel的第一个分类数据
 **/
export function getCategoryBFirstSubCategoryDetail() {

	return (dispatch, getState) => {
		let {categoryB} = getState();
		let {currentChannelId, currentChannelValue, categoryList, contentFetching} = categoryB;
		if (contentFetching) {
			return;
		}

		let category = categoryList.get(currentChannelValue) ? categoryList.get(currentChannelValue).get(0) : "";

		let category_id = category ? category.get('category_id') : "";
		let category_name = category ? category.get('category_name') : "";

		dispatch(setCurrentCateB(category_id, category_name))
		if(category){
			dispatch(getCategoryBSubCategoryDetail(category_id, category_name));
		}
	};
}


/**
 *在子分类的数据尾部添加一个MORE，因为需要获取relation_parameter 和 node_count数据，所以不得不从分类列表中筛选找出
 **/
function parseCategoryBSubDetail(channel_id, category_id, subcategory_data, props_data) {
	if(!subcategory_data || !props_data){
		return;
	}
	subcategory_data.lrts = new Date().getTime();
	let key = getSubDetailCacheKey(channel_id, category_id);

	return {key: key, data: subcategory_data};

}


export function getCategoryBListRequest() {
    return {
        type: GET_CATEGORY_B_LIST_REQUEST,
    };
}

export function getCategoryBListSuccess(json) {
    return {
        type: GET_CATEGORY_B_LIST_SUCCESS,
        payload: json
    }
}

export function getCategoryBListFailure(error) {
    return {
        type: GET_CATEGORY_B_LIST_FAILURE,
        payload: error
    }
}

export function getCategoryBSubDetailRequest() {
    return {
        type: GET_CATEGORY_B_SUBDETAIL_REQUEST,
    };
}

export function getCategoryBSubDetailSuccess(json) {
    return {
        type: GET_CATEGORY_B_SUBDETAIL_SUCCESS,
        payload: json
    }
}

export function getCategoryBSubDetailFailure(error) {
    return {
        type: GET_CATEGORY_B_SUBDETAIL_FAILURE,
        payload: error
    }
}


export function setCurrentCateB(categoryId, categoryValue){
	return {
        type: SET_CURRENT_CATEGORY_B,
        payload: {id: categoryId, value : categoryValue}
    }
}

export function setCurrentChannelB(channelId, channelValue){
	return {
        type: SET_CURRENT_CHANNEL_B,
        payload: {id: channelId, value : channelValue}
    }
}

export function getCategoryBSubDetailFromCache(categoryData) {
	return {
        type: SET_CURRENT_CATEGORY_B_SUBDETAIL_FROM_CACHE,
        payload: categoryData
    }
}


export function jumpToCategory(value, index, channelId){
	ReactNative.NativeModules.YH_CommonHelper.jumpToCategory(value, parseInt(index), parseInt(channelId));
	return {
        type: JUMP_TO_CATEGORY,
        payload: value
    }
}

export function startExposeData() {
	return (dispatch, getState) => {
		let {
			categoryB
		} = getState();

		let {
            currentChannelId,
            currentCateId,
            currentCateValue,
            cacheSubCateData,
            delayExposeData,
        } = categoryB;

        //检查缓存是否存在数据，如果不存在则获取
	    let key = getSubDetailCacheKey(currentChannelId, currentCateId);
	    let categoryData = cacheSubCateData ? cacheSubCateData.get(key) : "";
	    //已命中，展示缓存数据
	    if (categoryData) {
	        //曝光从缓存获取的数据
	        dispatch(dataExposure(currentChannelId, currentCateId, currentCateValue, categoryData.toJS()));
	    }
	}
}

function dataExposure(channel_id, category_id, category_value, json) {
	return (dispatch, getState) => {
		if (!json) {
			return;
		}

		try {
			let dataList = [];

			//bannerInfo数据曝光
			let bannerInfo = json.bannerInfo;
			if(bannerInfo && bannerInfo.length > 0){
				let bannerList = [];
				bannerInfo.map((item, i) => {
					bannerList.push({
	 					I_INDEX: i + 1 + '',
	 					F_URL: item.data[0].url,
					});
				})

				let bannerData = {
					L1_CATE: category_id + '',
					F_ID: '1001',
					F_NAME: 'BANNER',
					LIST: bannerList,
				}

				dataList.push(bannerData);
			}

			//sortInfo数据
			let sortInfo = json.sortInfo;
			if(sortInfo && sortInfo.length > 0){

				let sortList = [];
				sortInfo.map((item, i) => {
					sortList.push({
	 					I_INDEX: i + 1 + '',
	 					PRD_SKN: item.product_skn + '',
	 					L2_CATE: item.category_id + '',
					});
				})

				let sortData = {
					L1_CATE: category_id + '',
					F_ID: '1002',
					F_NAME: '全部'+category_value,
					LIST: sortList,
				}

				dataList.push(sortData);
			}

			//brandInfo数据
			let brandInfo = json.brandInfo;
			if(brandInfo && brandInfo.length > 0){

				let brandList = [];
				brandInfo.map((item, i) => {
					brandList.push({
	 					I_INDEX: i + 1 + '',
	 					BRAND_ID: item.id + '',
					});
				})

				let brandData = {
					L1_CATE: category_id + '',
					F_ID: '1003',
					F_NAME: '热门品牌',
					LIST: brandList,
				}

				dataList.push(brandData);
			}

			let params = {
				TAB_ID: channel_id + '',
				DATA: dataList,
			};

			ReactNative.NativeModules.YH_CommonHelper.logEvent('YB_SHOW_CATEGORY', params);
		} catch (e) {
			__DEV__ && console.error(e);
		} finally {

		}
	};
}