/*
 * Copyright (c) People Technologies Co., Ltd. 2019-2022. All rights reserved.
 */

package com.wd.display.comp.layoutmanager;

import java.util.ArrayList;
import java.util.List;

import androidx.annotation.NonNull;

import com.orhanobut.logger.Logger;
import com.people.component.comp.layoutdata.AbsGroup;
import com.people.component.comp.layoutdata.AbsPage;
import com.people.component.comp.layoutdata.AbsSection;
import com.people.component.comp.layoutdata.channel.BaseLineSection;
import com.people.component.comp.layoutmanager.channel.BaseLineLayoutManager;
import com.people.entity.custom.BaseLineBean;
import com.people.entity.custom.item.ItemBean;
import com.wondertek.wheat.ability.tools.ArrayUtils;

/**
 *
 */
public class Indexer {

    private static final String TAG = "Indexer";

    private List<ItemLayoutManager> itemLayoutManagers;

    public Indexer() {
        itemLayoutManagers = new ArrayList<>();
    }


    /**
     * 页面中多个楼层，每个楼层配置多个组件信息转换layoutManager，每次转换只对一个楼层中新增的组件信息转换
     * <p>
     * page
     *     groupA
     *            comp1 ->section1 ->layoutmanager1
     *            comp2 ->section2 ->layoutmanager2
     *            comp3 ->section3 ->layoutmanager3          收集转化成LayoutManager
     *            ....                                      ------------------------> List<ItemLayoutManager>
     *     groupB
     *           comp1 ->section1 ->layoutmanager1
     *           comp2 ->section2 ->layoutmanager2
     *           comp3 ->section3 ->layoutmanager3
     *           ...
     *      ...
     * <p>
     * 依据楼层更新itemLayoutManagers
     *
     * @param page      页面信息
     * @param isRefresh true：清理缓存数据
     */
    public void updateItemLayoutManagersByGroup(AbsPage page, boolean isRefresh) {
        Logger.t(TAG).d("updateItemLayoutManagers");

        if (page == null || page.getGroups() == null) {
            return;
        }

        // 刷新即清理LayoutManger
        if (isRefresh) {
            itemLayoutManagers.clear();
        }

        // 获取当前页面可支持需要加载更多数据的楼层对象
        AbsGroup group = page.getGroups().get(page.getGroupIndex());
        // comp在group里的下标

        int sectionSize = group.getSections().size();
        int groupIndex = group.getStartPosition();

        // j ：正在使用的楼层展示总数量
        int j =  group.getDisplayItemCount();

        int sectionIndex = -1+j;

        List<ItemBean> list;
        for (; j < sectionSize; ++j) {
            AbsSection section = group.getSections().get(j);
            if (section == null) {
                continue;
            }
            sectionIndex++;
            section.setPosition(sectionIndex);

            // 添加占位数据，如label是可以展示的，但是没有list，这里组装下占位数据；
            section.setupOrNotSection();

            // 根据展示数据list 进行展示，限制于displayCount
            if (section.getCompBean() == null || section.getCompBean().getDisplayItemBeans() == null) {
                continue;
            }
            int itemIndex = -1;
            list = new ArrayList<>();
            int sectionItemCount = section.getCompBean().getDisplayItemBeans().size();
            for (ItemBean itemBean : section.getCompBean().getDisplayItemBeans()) {
                if (itemBean == null) {
                    continue;
                }
                ItemLayoutManager layoutManager = page.getSectionParser().parseLayoutManager(section);
                if (layoutManager == null) {
                    continue;
                }
                itemIndex++;
                layoutManager.setFragment(page.getFragment());
                layoutManager.setItemIndex(new ItemIndex(groupIndex, sectionIndex, itemIndex, sectionItemCount));
                layoutManager.setSection(section);
                itemLayoutManagers.add(layoutManager);

                list.add(itemBean);

            }
            // 添加section里内容列表解析
            section.parseData(list);
        }

        Logger.t(TAG).d("updateItemLayoutManagers : " + itemLayoutManagers.size());
    }


    /**
     * 页面中一个楼层多个组件信息转换layoutManager，每次转换只对单个楼层中新增的组件信息转换
     *  page
     *      groupA
     *            comp1 ->section1 ->layoutmanager1
     *            comp2 ->section2 ->layoutmanager2
     *            comp3 ->section3 ->layoutmanager3          收集转化成LayoutManager
     *            ....                                      ------------------------> List<ItemLayoutManager>
     * <p>
     * 更新itemLayoutManagers
     *
     * @param page
     * @param isRefresh true：清理缓存数据
     */
    public void updateItemLayoutManagers(AbsPage page, boolean isRefresh) {
        Logger.t(TAG).d("updateItemLayoutManagers");

        if (page == null || page.getGroups() == null) {
            return;
        }

        // group在recyclerView里的下标
        int groupIndex = 0;

        int groupSize = page.getGroups().size();
        // 刷新即清理LayoutManger
        if (isRefresh) {
            itemLayoutManagers.clear();
        }
        List<ItemBean> list;
        for (int i = 0; i < groupSize; ++i) {
            AbsGroup group = page.getGroups().get(i);
            if (group.getSections() == null) {
                continue;
            }
            groupIndex = group.getStartPosition();
            // comp在group里的下标
            int sectionIndex = -1;
            int sectionSize = group.getSections().size();
            // group里，所有comp里的有效数据大小总和
            int groupItemCount = 0;

            int j = 0;
            if (groupSize == 1) {
                j = page.getDisplayItemCount();
            }
            for (; j < sectionSize; ++j) {
                AbsSection section = group.getSections().get(j);
                if (section == null) {
                    continue;
                }
                sectionIndex++;
                section.setPosition(sectionIndex);

                // 添加占位数据，如label是可以展示的，但是没有list，这里组装下占位数据；
                section.setupOrNotSection();

                // 根据展示数据list 进行展示，限制于displayCount
                if (section.getCompBean() == null || section.getCompBean().getDisplayItemBeans() == null) {
                    continue;
                }
                int itemIndex = -1;
                list = new ArrayList<>();
                int sectionItemCount = section.getCompBean().getDisplayItemBeans().size();
                for (ItemBean itemBean : section.getCompBean().getDisplayItemBeans()) {
                    if (itemBean == null) {
                        continue;
                    }
                    ItemLayoutManager layoutManager = page.getSectionParser().parseLayoutManager(section);
                    if (layoutManager == null) {
                        continue;
                    }
                    itemIndex++;
                    layoutManager.setFragment(page.getFragment());
                    layoutManager.setItemIndex(new ItemIndex(groupIndex, sectionIndex, itemIndex, sectionItemCount));
                    layoutManager.setSection(section);
                    itemLayoutManagers.add(layoutManager);
                    list.add(itemBean);

                }
                groupItemCount += sectionItemCount;
                // 添加section里内容列表解析
                section.parseData(list);
            }
        }
        Logger.t(TAG).d("updateItemLayoutManagers : " + itemLayoutManagers.size());
    }


    /**
     * 页面中多个楼层，每个楼层配置多个组件信息转换layoutManager，同时对多个楼层数据进行转换
     * <p>
     * page
     *     groupA
     *            comp1 ->section1 ->layoutmanager1
     *            comp2 ->section2 ->layoutmanager2
     *            comp3 ->section3 ->layoutmanager3          收集转化成LayoutManager
     *            ....                                      ------------------------> List<ItemLayoutManager>
     *     groupB
     *           comp1 ->section1 ->layoutmanager1
     *           comp2 ->section2 ->layoutmanager2
     *           comp3 ->section3 ->layoutmanager3
     *           ...
     *      ...
     * <p>
     * 依据楼层更新itemLayoutManagers
     *
     * @param page      页面信息
     */
    public void updateItemLayoutManagers(AbsPage page) {
        Logger.t(TAG).d("updateItemLayoutManagers");
        itemLayoutManagers.clear();
        if (page == null || page.getGroups() == null) {
            return;
        }
        // group在page里的下标，getGroups()里的下标
        int groupPosition = -1;
        // group在recyclerView里的下标
        int groupIndex = 0;
        AbsGroup group;
        AbsSection section;
        List<ItemBean> list;
        for (int i = 0; i < page.getGroups().size(); ++i) {
            group = page.getGroups().get(i);
            if (group.getSections() == null) {
                continue;
            }
            groupPosition++;
            group.setPosition(groupPosition);
            // 判断group数据是否完整，若数据不完整则整个Group不显示
            // boolean isDataIntegrity = group.checkoutIntegrity();
            // boolean isLoaded = group.hasDataLoaded();

            // comp在group里的下标
            int sectionIndex = -1;
            int sectionSize = group.getSections().size();
            group.setStartPosition(groupIndex);
            // group里，所有comp里的有效数据大小总和
            int groupItemCount = 0;
            for (int j = 0; j < sectionSize; ++j) {
                section = group.getSections().get(j);
                if (section == null) {
                    continue;
                }
                sectionIndex++;
                section.setPosition(sectionIndex);

                // 添加占位数据，如label是可以展示的，但是没有list，这里组装下占位数据；
                section.setupOrNotSection();

                // 根据展示数据list 进行展示，限制于displayCount
                if (section.getCompBean() == null || section.getCompBean().getDisplayItemBeans() == null) {
                    continue;
                }
                int itemIndex = -1;
                list = new ArrayList<>();
                int sectionItemCount = section.getCompBean().getDisplayItemBeans().size();
                for (ItemBean itemBean : section.getCompBean().getDisplayItemBeans()) {
                    if (itemBean == null) {
                        continue;
                    }
                    ItemLayoutManager layoutManager = page.getSectionParser().parseLayoutManager(section);
                    if (layoutManager == null) {
                        continue;
                    }
                    itemIndex++;
                    layoutManager.setFragment(page.getFragment());
                    // TODO new ItemIndex 用计算的方式解决，实现局部刷新
                    layoutManager.setItemIndex(new ItemIndex(groupIndex, sectionIndex, itemIndex, sectionItemCount));
                    layoutManager.setSection(section);
                    itemLayoutManagers.add(layoutManager);
                    list.add(itemBean);

                }
                groupItemCount += sectionItemCount;
                // 添加section里内容列表解析
                section.parseData(list);
            }
            groupIndex += groupItemCount;
        }
        Logger.t(TAG).d("updateItemLayoutManagers : " + itemLayoutManagers.size());
    }


    /**
     * 添加底线view
     *
     * @param baseLineBean 底线数据
     */
    public void addBaseLine(@NonNull BaseLineBean baseLineBean) {
        Logger.t(TAG).d("addBaseLine: " + baseLineBean.getLineHint());
        BaseLineLayoutManager lineLayoutManager = new BaseLineLayoutManager();
        BaseLineSection baseItemSection = new BaseLineSection(baseLineBean);
        lineLayoutManager.setSection(baseItemSection);
        itemLayoutManagers.add(lineLayoutManager);
        List<BaseLineBean> list = new ArrayList<BaseLineBean>() {
            {
                add(baseLineBean);
            }
        };
        lineLayoutManager.setItemIndex(new ItemIndex(0, 0, 0, 1));
        baseItemSection.parseData(list);
    }

    public void addItemLayoutManager(AbsSection section) {
        Logger.t(TAG).d("addItemLayoutManager");
        if (section == null || section.getCompBean() == null) {
            return;
        }

        List<ItemBean> itemBeans = section.getCompBean().getDisplayItemBeans();
        if (ArrayUtils.isEmpty(itemBeans)) {
            return;
        }
        List<ItemLayoutManager> managers = new ArrayList<>();
        int groupIndex = section.getParent().getStartPosition();
        int sectionIndex = section.getPosition();
        int itemSize = itemBeans.size();
        int prePosition = groupIndex;
        List<ItemBean> list = new ArrayList<>();
        for (ItemBean itemBean : itemBeans) {
            if (itemBean == null) {
                continue;
            }
            ItemLayoutManager layoutManager =
                    section.getParent().getParent().getSectionParser().parseLayoutManager(section);
            if (layoutManager == null) {
                continue;
            }
            // layoutManager.setFragment(page.getFragment());
            layoutManager.setItemIndex(new ItemIndex(groupIndex, sectionIndex, itemSize));
            layoutManager.setSection(section);
            managers.add(layoutManager);
            list.add(itemBean);
        }
        // 添加section里内容列表解析
        section.parseData(list);
        itemLayoutManagers.addAll(prePosition, managers);
        Logger.t(TAG).d("addItemLayoutManager : " + itemLayoutManagers.size());
    }

    /**
     *
     */
    private int getStartPosition(@NonNull AbsSection section) {
        return section.getParent().getStartPosition();
    }

    public void removeItemLayoutManager(int position) {
        itemLayoutManagers.remove(position);
        Logger.t("TAG").e("removeItemLayoutManager : " + itemLayoutManagers.size());
    }

    /**
     * 插入/删除item后，更新index
     *
     * @param startIndex 开始位置
     * @param offset     更新位移，即变化量；如插入了3条，offset=3；删除了3条，offset=-3
     */
    public void updateIndexer(int startIndex, int offset) {
        if (startIndex >= itemLayoutManagers.size()) {
            return;
        }
        for (int i = startIndex; i < itemLayoutManagers.size(); i++) {
            // 后面所有的item，下标刷新
            ItemLayoutManager itemLayoutManager = itemLayoutManagers.get(i);
            ItemIndex itemIndex = itemLayoutManager.getItemIndex();
            if (itemIndex == null) {
                continue;
            }

            int groupIndex = itemIndex.getGroupIndex() + offset;
            itemIndex.setGroupIndex(groupIndex);
            // 下标更新到group里
            if (itemLayoutManager.getSection() != null && itemLayoutManager.getSection().getParent() != null) {
                itemLayoutManager.getSection().getParent().setStartPosition(groupIndex);
            }
        }
    }

    public int getItemCount() {
        return itemLayoutManagers == null ? 0 : itemLayoutManagers.size();
    }

    public List<ItemLayoutManager> getItemLayoutManagers() {
        return itemLayoutManagers;
    }

    public void setItemLayoutManagers(List<ItemLayoutManager> itemLayoutManagers) {
        this.itemLayoutManagers = itemLayoutManagers;
    }

    /**
     * 获取在<code>position</code>位置的item的layout manager
     */
    ItemLayoutManager layoutMangerInPosition(int position) {
        for (ItemLayoutManager lm : itemLayoutManagers) {
            if (lm.getItemIndex() == null || lm.getItemIndex().getItemCount() == 0) {
                continue;
            }
            int lastItemPosition = lm.getItemIndex().getLastItemPosition();
            if (position < lastItemPosition) {
                return (ItemLayoutManager) lm;
            }
        }

        return null;
        // return searchManager(position);
    }
}