import { Logger, SPHelper, StringUtils, UserDataLocal } from 'wdKit';
import { HttpUrlUtils, ResponseDTO, WDHttp } from 'wdNetwork';
import { SearchHistoryItem } from '../viewmodel/SearchHistoryItem';
import { SearchHotContentItem } from '../viewmodel/SearchHotContentItem';
import { SearchResultCountItem } from '../viewmodel/SearchResultCountItem';
import { SearchResultContentData } from '../viewmodel/SearchResultContentData';
import { ContentDTO, contentListParams, InteractDataDTO } from 'wdBean/Index';
import { CreatorDetailRequestItem } from '../viewmodel/CreatorDetailRequestItem';
import { CreatorDetailResponseItem } from '../viewmodel/CreatorDetailResponseItem';
import { SearchSuggestRequestItem } from '../viewmodel/SearchSuggestRequestItem';

const TAG = "SearcherAboutDataModel"

/**
 * 我的页面 所有数据 获取封装类
 */
class SearcherAboutDataModel{
  private static instance: SearcherAboutDataModel;
  public searchHistoryData:SearchHistoryItem[] = []
  public SEARCH_HISTORY_KEY:string = "SEARCH_HISTORY_KEY"

  private constructor() { }

  /**
   * 单例模式
   * @returns
   */
  public static getInstance(): SearcherAboutDataModel {
    if (!SearcherAboutDataModel.instance) {
      SearcherAboutDataModel.instance = new SearcherAboutDataModel();
    }
    return SearcherAboutDataModel.instance;
  }

  /**
   * 插入搜索记录（单个）
   */
  public async putSearchHistoryData(content:string){
    let history = SPHelper.default.getSync(this.generationSearchKey(),"[]") as string
    this.searchHistoryData = JSON.parse(history)
    this.searchHistoryData.forEach((element,index) => {
      if (element.searchContent == content) {
        this.searchHistoryData.splice(index,1)
      }
    });
    this.searchHistoryData.splice(0,0,new SearchHistoryItem(content))
    await SPHelper.default.saveSync(this.generationSearchKey(), JSON.stringify(this.searchHistoryData));
  }

  /**
   * 删除搜索记录（所有）
   */
  public async delSearchHistoryData(){
    SPHelper.default.deleteSync(this.generationSearchKey())
    this.searchHistoryData = []
  }
  /**
   * 删除搜索记录（单个）
   */
  public async delSearchSingleHistoryData(index:number){
    if(this.searchHistoryData!=null && this.searchHistoryData.length>0){
      this.searchHistoryData.splice(index,1)
    }else{
      let history = SPHelper.default.getSync(this.generationSearchKey(),"[]") as string
      this.searchHistoryData = JSON.parse(history)
      this.searchHistoryData.splice(index,1)
    }
    SPHelper.default.saveSync(this.generationSearchKey(), JSON.stringify(this.searchHistoryData))
  }

  /**
   * 查询搜索记录（所有）
   */
  public getSearchHistoryData() : SearchHistoryItem[] {
    if(this.searchHistoryData!=null && this.searchHistoryData.length>0){
      if(this.searchHistoryData.length>10){
        this.searchHistoryData.splice(10,this.searchHistoryData.length - 10)
      }
      return this.searchHistoryData
    }
    let history = SPHelper.default.getSync(this.generationSearchKey(),"[]") as string

    this.searchHistoryData = JSON.parse(history)
    if(this.searchHistoryData.length>10){
      this.searchHistoryData.splice(10,this.searchHistoryData.length - 10)
    }
    // this.putSearchHistoryData("大家")
    // this.putSearchHistoryData("人民")

    return  this.searchHistoryData
  }

  public generationSearchKey():string{
    let userId = UserDataLocal.getUserId()
    if(StringUtils.isEmpty(userId)){
      return this.SEARCH_HISTORY_KEY + "_" + "0000111122223333"
    }else{
      return this.SEARCH_HISTORY_KEY + "_" + userId
    }
  }

  /**
   * 首页 搜索提示滚动内容
   */
  getSearchHintData(context: Context): Promise<string[]> {
    return new Promise<string[]>((success, error) => {
      Logger.info(TAG, `getSearchHintData start`);
      this.fetchSearchHintData().then((navResDTO: ResponseDTO<string[]>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getSearchHintData then,SearchHintDataResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as string[]
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `fetchSearchHintData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchSearchHintData() {
    let url = HttpUrlUtils.getSearchHintDataUrl()
    return WDHttp.get<ResponseDTO<string[]>>(url)
  };


  /**
   * 搜索主页 热词
   */
  getSearchHotsData(context: Context): Promise<SearchHotContentItem[]> {
    return new Promise<SearchHotContentItem[]>((success, error) => {
      Logger.info(TAG, `getSearchHintData start`);
      this.fetchSearchHotsData().then((navResDTO: ResponseDTO<SearchHotContentItem[]>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getSearchHotsData then,getSearchHotsData.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as SearchHotContentItem[]
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `getSearchHotsData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchSearchHotsData() {
    let url = HttpUrlUtils.getSearchHotsDataUrl()
    return WDHttp.get<ResponseDTO<SearchHotContentItem[]>>(url)
  };

  /**
   * 搜索 联想词
   */
  getRelatedSearchContentData(keyword:string,context: Context): Promise<string[]> {
    return new Promise<string[]>((success, error) => {
      Logger.info(TAG, `getSearchHintData start`);
      this.fetchRelatedSearchContentData(keyword).then((navResDTO: ResponseDTO<string[]>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getSearchHintData then,SearchHintDataResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as string[]
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `fetchSearchHintData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchRelatedSearchContentData(keyword:string) {
    let url = HttpUrlUtils.getRelatedSearchContentDataUrl()+ keyword
    return WDHttp.get<ResponseDTO<string[]>>(url)
  };

  /**
   * 搜索结果 展示tab数量
   */
  getSearchResultCountData(keyword:string,context: Context): Promise<SearchResultCountItem> {
    return new Promise<SearchResultCountItem>((success, error) => {
      Logger.info(TAG, `getSearchResultCountData start`);
      this.fetchSearchResultCountData(keyword).then((navResDTO: ResponseDTO<SearchResultCountItem>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getSearchResultCountData then,SearchHintDataResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as SearchResultCountItem
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `getSearchResultCountData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchSearchResultCountData(keyword:string) {
    let url = HttpUrlUtils.getSearchResultCountDataUrl() + keyword
    return WDHttp.get<ResponseDTO<SearchResultCountItem>>(url)
  };

  /**
   * 搜索结果 展示列表
   */
  getSearchResultListData(pageSize:string,pageNum:string,searchType:string,keyword:string,context: Context): Promise<SearchResultContentData> {
    return new Promise<SearchResultContentData>((success, error) => {
      Logger.info(TAG, `getSearchResultListData start`);
      this.fetchSearchResultListData(pageSize,pageNum,searchType,keyword).then((navResDTO: ResponseDTO<SearchResultContentData>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getSearchResultListData then,SearchResultListResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as SearchResultContentData
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `getSearchResultListData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchSearchResultListData(pageSize:string,pageNum:string,searchType:string,keyword:string) {
    let url = HttpUrlUtils.getSearchResultListDataUrl() + `?pageSize=${pageSize}&pageNum=${pageNum}&searchType=${searchType}&keyword=${keyword}`
    return WDHttp.get<ResponseDTO<SearchResultContentData>>(url)
  };

  /**
   * 搜索结果 展示列表（交互详情  评论收藏点赞分享数量）
   */
  getInteractListData(data : contentListParams,context: Context): Promise<InteractDataDTO[]> {
    return new Promise<InteractDataDTO[]>((success, error) => {
      Logger.info(TAG, `getInteractListData start`);
      this.fetchInteractListData(data).then((navResDTO: ResponseDTO<InteractDataDTO[]>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getInteractListData then,SearchResultListResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as InteractDataDTO[]
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `getInteractListData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchInteractListData(data : contentListParams) {
    let url = HttpUrlUtils.getInteractListDataUrl()
    return WDHttp.post<ResponseDTO<InteractDataDTO[]>>(url,data)
  };

  /**
   * 获取关注详情 列表
   */
  getCreatorDetailListData(object:CreatorDetailRequestItem): Promise<CreatorDetailResponseItem[]> {
    return new Promise<CreatorDetailResponseItem[]>((success, error) => {
      Logger.info(TAG, `getCreatorDetailListData start`);
      this.fetchCreatorDetailListData(object).then((navResDTO: ResponseDTO<CreatorDetailResponseItem[]>) => {
        if (!navResDTO || navResDTO.code != 0) {
          error(null)
          return
        }
        Logger.info(TAG, "getCreatorDetailListData then,SearchResultListResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as CreatorDetailResponseItem[]
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `getCreatorDetailListData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchCreatorDetailListData(object:CreatorDetailRequestItem) {
    let url = HttpUrlUtils.getCreatorDetailListDataUrl()
    return WDHttp.post<ResponseDTO<CreatorDetailResponseItem[]>>(url,object)
  };

  /**
   * 搜索推荐 展示列表
   */
  getSearchSuggestData(object:SearchSuggestRequestItem,context: Context): Promise<ContentDTO[]> {
    return new Promise<ContentDTO[]>((success, error) => {
      Logger.info(TAG, `getSearchSuggestData start`);
      this.fetchSearchSuggestData(object).then((navResDTO: ResponseDTO<ContentDTO[]>) => {
        if (!navResDTO || navResDTO.code != 0 ) {
          error(null)
          return
        }
        Logger.info(TAG, "getSearchSuggestData then,SearchResultListResDTO.timeStamp:" + navResDTO.timestamp);
        let navigationBean = navResDTO.data as ContentDTO[]
        success(navigationBean);
      }).catch((err: Error) => {
        Logger.error(TAG, `getSearchSuggestData catch, error.name : ${err.name},  error.message:${err.message}`);
        error(null)
      })
    })
  }

  fetchSearchSuggestData(object:SearchSuggestRequestItem) {
    let url = HttpUrlUtils.getSearchSuggestDataUrl()
    return WDHttp.post<ResponseDTO<ContentDTO[]>>(url,object)
  };

}

const searcherAboutDataModel = SearcherAboutDataModel.getInstance()
export default searcherAboutDataModel as SearcherAboutDataModel