'use strict';

import ReactNative from 'react-native';
import BrandService from '../../services/BrandService';
import {Record, List, Map} from 'immutable';
import Pinyin from '../../../common/utils/pinyin';
import {isEmptyObject} from '../../utils/Utils';

const {
	SET_TYPE,

	SET_BRAND_FILTER,
	SET_BRAND_SELECTED_CHANNEL,
	SET_INITIALLISTSIZE,
	GET_BRAND_LIST_FOR_BOY_REQUEST,
	GET_BRAND_LIST_FOR_BOY_SUCCESS,
	GET_BRAND_LIST_FOR_BOY_FAILURE,

	GET_BRAND_LIST_FOR_GIRL_REQUEST,
	GET_BRAND_LIST_FOR_GIRL_SUCCESS,
	GET_BRAND_LIST_FOR_GIRL_FAILURE,

	GET_BRAND_LIST_FOR_KID_REQUEST,
	GET_BRAND_LIST_FOR_KID_SUCCESS,
	GET_BRAND_LIST_FOR_KID_FAILURE,

	GET_BRAND_LIST_FOR_LIFESTYLE_REQUEST,
	GET_BRAND_LIST_FOR_LIFESTYLE_SUCCESS,
	GET_BRAND_LIST_FOR_LIFESTYLE_FAILURE,

	GET_BRAND_RESOURCE_FOR_BOY_REQUEST,
	GET_BRAND_RESOURCE_FOR_BOY_SUCCESS,
	GET_BRAND_RESOURCE_FOR_BOY_FAILURE,

	GET_BRAND_RESOURCE_FOR_GIRL_REQUEST,
	GET_BRAND_RESOURCE_FOR_GIRL_SUCCESS,
	GET_BRAND_RESOURCE_FOR_GIRL_FAILURE,

	GET_BRAND_RESOURCE_FOR_KID_REQUEST,
	GET_BRAND_RESOURCE_FOR_KID_SUCCESS,
	GET_BRAND_RESOURCE_FOR_KID_FAILURE,

	GET_BRAND_RESOURCE_FOR_LIFESTYLE_REQUEST,
	GET_BRAND_RESOURCE_FOR_LIFESTYLE_SUCCESS,
	GET_BRAND_RESOURCE_FOR_LIFESTYLE_FAILURE,

	SET_BRAND_DATA_FOR_BOY,
	SET_BRAND_DATA_FOR_GIRL,
	SET_BRAND_DATA_FOR_KID,
	SET_BRAND_DATA_FOR_LIFESTYLE,

	BRAND_SHOW_SEARCH,
	FETCH_BRAND_SEARCH_HISTORY,
    INSERT_BRAND_SEARCH_HISTORY,
    CLEAR_BRAND_SEARCH_HISTORY,
    BRAND_HOT_KEYWORD_REQUEST,
    BRAND_HOT_KEYWORD_SUCCESS,
    BRAND_HOT_KEYWORD_FAILURE,
    FILTE_BRAND_LIST,
    SET_BRAND_KEYWORD,

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


export function setBrandFilter(filter) {
	return {
		type: SET_BRAND_FILTER,
		payload: filter
	};
}

export function setBrandSelectedChannel(channelId) {
	return {
		type: SET_BRAND_SELECTED_CHANNEL,
		payload: channelId
	};
}

export function setShowSearch(show) {
	return {
		type: BRAND_SHOW_SEARCH,
		payload: show
	};
}

export function getBrandListForBoyRequest() {
    return {
        type: GET_BRAND_LIST_FOR_BOY_REQUEST,
    };
}

export function getBrandListForBoySuccess(json) {
    return {
        type: GET_BRAND_LIST_FOR_BOY_SUCCESS,
        payload: json
    }
}

export function getBrandListForBoyFailure(error) {
    return {
        type: GET_BRAND_LIST_FOR_BOY_FAILURE,
        payload: error
    }
}

export function getBrandListForGirlRequest() {
    return {
        type: GET_BRAND_LIST_FOR_GIRL_REQUEST,
    };
}

export function getBrandListForGirlSuccess(json) {
    return {
        type: GET_BRAND_LIST_FOR_GIRL_SUCCESS,
        payload: json
    }
}

export function getBrandListForGirlFailure(error) {
    return {
        type: GET_BRAND_LIST_FOR_GIRL_FAILURE,
        payload: error
    }
}

export function getBrandListForKidRequest() {
    return {
        type: GET_BRAND_LIST_FOR_KID_REQUEST,
    };
}

export function getBrandListForKidSuccess(json) {
    return {
        type: GET_BRAND_LIST_FOR_KID_SUCCESS,
        payload: json
    }
}

export function getBrandListForKidFailure(error) {
    return {
        type: GET_BRAND_LIST_FOR_KID_FAILURE,
        payload: error
    }
}

export function getBrandListForLifeStyleRequest() {
    return {
        type: GET_BRAND_LIST_FOR_LIFESTYLE_REQUEST,
    };
}

export function getBrandListForLifeStyleSuccess(json) {
    return {
        type: GET_BRAND_LIST_FOR_LIFESTYLE_SUCCESS,
        payload: json
    }
}

export function getBrandListForLifeStyleFailure(error) {
    return {
        type: GET_BRAND_LIST_FOR_LIFESTYLE_FAILURE,
        payload: error
    }
}

export function getBrandList(channel) {
	return (dispatch, getState) => {
		let {app, classify} = getState();
		if (channel == 1) {
			dispatch(getBrandListForBoyRequest());
		}else if (channel == 2) {
			dispatch(getBrandListForGirlRequest());
		}else if (channel == 3) {
			dispatch(getBrandListForKidRequest());
		}else if (channel == 4) {
			dispatch(getBrandListForLifeStyleRequest());
		}
		return new BrandService(app.host).getBrandList(channel)
        .then(json => {

			let payload = parseListResources(json);

			if (channel == 1) {
				dispatch(getBrandListForBoySuccess(payload));
			}else if (channel == 2) {
				dispatch(getBrandListForGirlSuccess(payload));
			}else if (channel == 3) {
				dispatch(getBrandListForKidSuccess(payload));
			}else if (channel == 4) {
				dispatch(getBrandListForLifeStyleSuccess(payload));
			}
		})
		.catch(error => {
			if (channel == 1) {
				dispatch(getBrandListForBoyFailure(error));
			}else if (channel == 2) {
				dispatch(getBrandListForGirlFailure(error));
			}else if (channel == 3) {
				dispatch(getBrandListForKidFailure(error));
			}else if (channel == 4) {
				dispatch(getBrandListForLifeStyleFailure(error));
			}
		});
	};
}

export function parseListResources(json) {
	let all_list_old = json.all_list;
	let hot_list = json.hot_list;
	let new_list = json.new_list;

	if (isEmptyObject(all_list_old)) {
		return json;
	}

	let reg = /^[a-zA-Z]*$/;
	let all_list = {};
	let otherList = [];
	let all_list_key = {};

	for(let k in all_list_old) {

		if (reg.test(k)) {
			all_list_key[k] = {
				key:k,
			};
			all_list[k] = all_list_old[k];
		} else {
			Array.prototype.push.apply(otherList, all_list_old[k]);
		}
	}

	all_list['0-9'] = otherList;
	all_list_key['0-9'] = {
		key:'0-9',
	};

	return {
		all_list,
		hot_list,
		new_list,
		all_list_key,
    };
}

export function getBrandResourceForBoyRequest() {
    return {
        type: GET_BRAND_RESOURCE_FOR_BOY_REQUEST,
    };
}

export function getBrandResourceForBoySuccess(json) {
    return {
        type: GET_BRAND_RESOURCE_FOR_BOY_SUCCESS,
        payload: json
    }
}

export function getBrandResourceForBoyFailure(error) {
    return {
        type: GET_BRAND_RESOURCE_FOR_BOY_FAILURE,
        payload: error
    }
}

export function getBrandResourceForGirlRequest() {
    return {
        type: GET_BRAND_RESOURCE_FOR_GIRL_REQUEST,
    };
}

export function getBrandResourceForGirlSuccess(json) {
    return {
        type: GET_BRAND_RESOURCE_FOR_GIRL_SUCCESS,
        payload: json
    }
}

export function getBrandResourceForGirlFailure(error) {
    return {
        type: GET_BRAND_RESOURCE_FOR_GIRL_FAILURE,
        payload: error
    }
}

export function getBrandResourceForKidRequest() {
    return {
        type: GET_BRAND_RESOURCE_FOR_KID_REQUEST,
    };
}

export function getBrandResourceForKidSuccess(json) {
    return {
        type: GET_BRAND_RESOURCE_FOR_KID_SUCCESS,
        payload: json
    }
}

export function getBrandResourceForKidFailure(error) {
    return {
        type: GET_BRAND_RESOURCE_FOR_KID_FAILURE,
        payload: error
    }
}

export function getBrandResourceForLifeStyleRequest() {
    return {
        type: GET_BRAND_RESOURCE_FOR_LIFESTYLE_REQUEST,
    };
}

export function getBrandResourceForLifeStyleSuccess(json) {
    return {
        type: GET_BRAND_RESOURCE_FOR_LIFESTYLE_SUCCESS,
        payload: json
    }
}

export function getBrandResourceForLifeStyleFailure(error) {
    return {
        type: GET_BRAND_RESOURCE_FOR_LIFESTYLE_FAILURE,
        payload: error
    }
}

export function getBrandResource(channel) {
	return (dispatch, getState) => {
		let {app, classify} = getState();
		let content_code;
		if (channel == 1) {
			dispatch(getBrandResourceForBoyRequest());
			content_code = 'ce6ac059493ec26241a8cbe0bfa1b17a';
		}else if (channel == 2) {
			dispatch(getBrandResourceForGirlRequest());
			content_code = 'dac99cdedc1f948e84c145aca561f7d2';
		}else if (channel == 3) {
			dispatch(getBrandResourceForKidRequest());
			content_code = '713784f93f52bb1a7b93916b2bb15510';
		}else if (channel == 4) {
			dispatch(getBrandResourceForLifeStyleRequest());
			content_code = 'f1aa914fd23cbcda71a87de6f5416c75';
		}

		return new BrandService(app.serviceHost).getBrandResource(content_code)
        .then(json => {
			let payload = parseResourceResources(json);
			if (channel == 1) {
				dispatch(getBrandResourceForBoySuccess(payload));
			}else if (channel == 2) {
				dispatch(getBrandResourceForGirlSuccess(payload));
			}else if (channel == 3) {
				dispatch(getBrandResourceForKidSuccess(payload));
			}else if (channel == 4) {
				dispatch(getBrandResourceForLifeStyleSuccess(payload));
			}
		})
		.catch(error => {
			if (channel == 1) {
				dispatch(getBrandResourceForBoyFailure(error));
			}else if (channel == 2) {
				dispatch(getBrandResourceForGirlFailure(error));
			}else if (channel == 3) {
				dispatch(getBrandResourceForKidFailure(error));
			}else if (channel == 4) {
				dispatch(getBrandResourceForLifeStyleFailure(error));
			}
		});
	};
}

export function parseResourceResources(json) {

	let banner = [];
	let custom_brands = [];
	let brandsText = [];

	brandsText.push({key: 'default',name: '全部品牌'});

	for (var i = 0; i < json.length; i++) {
		if (json[i].template_name == 'focus') {
			banner = json[i];
		}
		if (json[i].template_name == 'custom_brands') {
			custom_brands = json[i];
		}
		if (json[i].template_name == 'text') {
			let data = json[i].data;
			let template_id = json[i].template_id;
			let text = data.text;
			brandsText.push({key: template_id,name: text});
		}
	}

    return {
		banner,
		custom_brands,
		brandsText,
    };
}


export function searchHistory() {
	return (dispatch, getState) => {
		ReactNative.NativeModules.YH_ClassifyHelper.fetchSearchHistory()
		.then(data => {
			dispatch({
		        type: FETCH_BRAND_SEARCH_HISTORY,
		        payload: parseSearchHistory(data)
		    });
		})
		.catch(error => {

		});
	};
}

export function insertSearchHistory(keyword) {
	return (dispatch, getState) => {
		ReactNative.NativeModules.YH_ClassifyHelper.insertSearchHistory(keyword)
		.then(data => {
			dispatch({
		        type: INSERT_BRAND_SEARCH_HISTORY,
		        payload: parseSearchHistory(data)
		    });
		})
		.catch(error => {

		});
	};
}

export function clearSearchHistory() {
	return (dispatch, getState) => {
		ReactNative.NativeModules.YH_ClassifyHelper.clearSearchHistory()
		.then(data => {
			dispatch({
		        type: CLEAR_BRAND_SEARCH_HISTORY,
		        payload: parseSearchHistory(data)
		    });
		})
		.catch(error => {

		});
	};
}

function parseSearchHistory(data) {
	let list = [];
	data.map((item, i) => {
		list.push({keyword: item});
	});

	return list;
}

export function hotKeywordRequest() {
    return {
        type: BRAND_HOT_KEYWORD_REQUEST,
    };
}

export function hotKeywordSuccess(json) {
    return {
        type: BRAND_HOT_KEYWORD_SUCCESS,
        payload: json
    };
}

export function hotKeywordFailure(error) {
    return {
        type: BRAND_HOT_KEYWORD_FAILURE,
        payload: error
    };
}


export function hotKeyword(reload=false) {
	return (dispatch, getState) => {
		let {app, brand} = getState();
		let {search} = brand;
        let {isFetching} = search;
		if (reload) {
			// 强制刷新数据

		} else {
			if (isFetching) {
				return;
			}
		}

		let fetchHotKeyword = (uid) => {
			dispatch(hotKeywordRequest());
			return new BrandService(app.host).fetchHotKeyword(uid)
			.then(json => {
				let payload = parseHotKeyword(json);
				dispatch(hotKeywordSuccess(payload));
			})
			.catch(error => {
				dispatch(hotKeywordFailure(error));
			});
		}

		ReactNative.NativeModules.YH_CommonHelper.uid()
		.then(uid => {
			fetchHotKeyword(uid);
		})
		.catch(error => {
			fetchHotKeyword(0);
		});
	};
}

function parseHotKeyword(json) {
	let list = [];
	Array.isArray(json) && json.map((item, i) => {
		let brandName = item.brandName ? item.brandName : '';
		let keyword = brandName;
		let brandDomain = item.brandDomain ? item.brandDomain : '';
		let brandId = item.brandId ? item.brandId : '';
		list.push({keyword, brandName, brandDomain, brandId});
	});

	return {
		list,
	};
}

export function filtedBrandList(data) {
	return {
		type: FILTE_BRAND_LIST,
		payload: data,
	};
}

export function filteBrandForKeyword(text) {
	return (dispatch, getState) => {
		let {app, brand} = getState();
		let {brandChannelFliter, brandListForBoy, brandListForGirl, brandListForKid, brandListForLifeStyle} = brand;

		let brandList = Map();
		if (brandChannelFliter == 1) {
			brandList = brandListForBoy.all_list;
		} else if (brandChannelFliter == 2) {
			brandList = brandListForGirl.all_list;
		} else if (brandChannelFliter == 3) {
			brandList = brandListForKid.all_list;
		} else {
			brandList = brandListForLifeStyle.all_list;
		}

		let result = {

		};

		if (!text) {
			dispatch(filtedBrandList(result));
			return;
		}

		text = text.toLowerCase();

		let pinyin = new Pinyin(false, 'lower');

		brandList && brandList.map((value, key) => {
			let matchs = value.filter((v, k) => {
				let name = v.get('brand_name', '').toLowerCase();
				let cnName = v.get('brand_name_cn', '').toLowerCase();
				let enName = v.get('brand_name_en', '').toLowerCase();

				let nameFirstLetter = pinyin.getCamelChars(name).toLowerCase();
				let nameAllLetter = pinyin.getFullChars(name);

				if (name.includes(text)
					|| cnName.includes(text)
					|| enName.includes(text)
					|| nameFirstLetter.includes(text)
					|| nameAllLetter.includes(text)) {

					return true;
				}

				return false;
			});

			result[key] = matchs;
		});

		dispatch(filtedBrandList(result));

	};
}

export function setBrandKeyword(keyword) {
	return {
		type: SET_BRAND_KEYWORD,
		payload: keyword
	};
}

export function setBrandDataKeyForBoy(data) {
	return {
		type: SET_BRAND_DATA_FOR_BOY,
		payload: data
	};
}
export function setBrandDataKeyForGirl(data) {
	return {
		type: SET_BRAND_DATA_FOR_GIRL,
		payload: data
	};
}
export function setBrandDataKeyForkid(data) {
	return {
		type: SET_BRAND_DATA_FOR_KID,
		payload: data
	};
}
export function setBrandDataKeyForLifeStyle(data) {
	return {
		type: SET_BRAND_DATA_FOR_LIFESTYLE,
		payload: data
	};
}

export function setBrandData(data,brandChannelFliter) {
	return (dispatch, getState) => {
		if (brandChannelFliter == 1) {
			dispatch(setBrandDataKeyForBoy(data));
		}else if (brandChannelFliter == 2) {
			dispatch(setBrandDataKeyForGirl(data));
		}else if (brandChannelFliter == 3) {
			dispatch(setBrandDataKeyForkid(data));
		}else if (brandChannelFliter == 4) {
			dispatch(setBrandDataKeyForLifeStyle(data));
		}
	}
}

export function setInitialListSizePar(count) {
	return {
		type: SET_INITIALLISTSIZE,
		payload: count
	};
}

export function setInitialListSize(count) {
	return (dispatch, getState) => {
		dispatch(setInitialListSizePar(count));
	}
}