package com.fujica.abk.component.nav;

import com.fujica.abk.ResourceTable;
import com.fujica.abk.component.LoadingComponent;
import com.fujica.abk.component.ParkItemComponent;
import com.fujica.abk.model.out.ParkNearRes;
import com.fujica.abk.model.out.Page;
import com.fujica.abk.utils.*;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import ohos.agp.components.*;
import com.fujica.abk.utils.CustomListDialog;
import ohos.app.Context;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;
import ohos.location.Location;

import java.lang.reflect.Type;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

/**
 * 找车位页面组件
 */
public class ParkComponent extends DirectionalLayout {
    // 页面组件
    private Component rootLayout;
    private TextField inputParkName; // 车场名称输入框
    private DirectionalLayout btnDistanceFilter; // 距离筛选按钮
    private DirectionalLayout btnDistanceSort; // 排序方式按钮
    private ScrollView parkingListScroll; // 停车场列表滚动视图
    private DirectionalLayout parkingListContainer; // 停车场列表容器

    // 筛选和排序参数
    private int selectedDistance = 3000; // 选中的距离：500, 1000, 3000（默认3km）
    private int selectedFilter = 2; // 选中的排序：1=车位最多, 2=距离最近, 3=免费时长最长（默认距离最近）
    private int filterType = 2; // 筛选类型：2=全部，1=推荐

    // 分页相关
    private int currentPage = 1; // 当前页码
    private int pageSize = 20; // 每页数量
    private boolean isLoading = false; // 是否正在加载
    private boolean hasMore = true; // 是否还有更多数据
    private long lastLoadTime = 0; // 上次加载时间，用于防抖
    private static final long LOAD_THROTTLE_MS = 500; // 防抖时间间隔（毫秒）

    // 数据
    private List<ParkNearRes> parkingList = new ArrayList<>(); // 停车场列表数据
    private ParkItemComponent selectedParkingItem = null; // 当前选中的停车场列表项
    private EventHandler searchHandler; // 搜索防抖Handler

    // 外部依赖
    private Context context;
    private Location currentLocation; // 当前定位坐标
    private LoadingComponent loadingComponent; // Loading组件
    private OnParkSelectedListener onParkSelectedListener; // 停车场选中监听器

    /**
     * 停车场选中监听器
     */
    public interface OnParkSelectedListener {
        void onParkSelected(ParkNearRes park);
        void onParkDeselected();
    }

    /**
     * 构造函数
     */
    public ParkComponent(Context context) {
        super(context);
        this.context = context;
        initComponent(context);
    }

    /**
     * 初始化组件
     */
    private void initComponent(Context context) {
        // 设置布局属性
        setWidth(ComponentContainer.LayoutConfig.MATCH_PARENT);
        setHeight(ComponentContainer.LayoutConfig.MATCH_PARENT);
        setOrientation(VERTICAL);

        // 加载布局文件
        rootLayout = LayoutScatter.getInstance(context)
                .parse(ResourceTable.Layout_layout_park, null, false);
        addComponent(rootLayout);

        // 初始化组件引用
        initViews();

        // 设置事件监听
        setupListeners();

        // 默认选中全部车场
        switchTab(2);
    }

    /**
     * 初始化视图组件
     */
    private void initViews() {
        inputParkName = (TextField) rootLayout.findComponentById(ResourceTable.Id_input_park_name);
        btnDistanceFilter = (DirectionalLayout) rootLayout.findComponentById(ResourceTable.Id_btn_distance_filter);
        btnDistanceSort = (DirectionalLayout) rootLayout.findComponentById(ResourceTable.Id_btn_distance_sort);
        parkingListScroll = (ScrollView) rootLayout.findComponentById(ResourceTable.Id_parking_list_scroll);
        parkingListContainer = (DirectionalLayout) rootLayout.findComponentById(ResourceTable.Id_parking_list_container);
    }

    /**
     * 设置事件监听
     */
    private void setupListeners() {
        // 设置距离筛选下拉框点击事件
        if (btnDistanceFilter != null) {
            btnDistanceFilter.setClickedListener(component -> showDistanceFilterDialog());
        }

        // 设置排序方式下拉框点击事件
        if (btnDistanceSort != null) {
            btnDistanceSort.setClickedListener(component -> showSortFilterDialog());
        }

        // 设置车场名称输入框值改变监听器（带防抖）
        if (inputParkName != null) {
            // 创建用于防抖的Handler
            searchHandler = new EventHandler(EventRunner.getMainEventRunner());
            
            inputParkName.addTextObserver(new Text.TextObserver() {
                @Override
                public void onTextUpdated(String s, int i, int i1, int i2) {
                    // 移除之前的搜索任务
                    searchHandler.removeAllEvent();
                    
                    // 延迟执行查询，实现防抖效果
                    searchHandler.postTask(() -> {
                        // 重新加载数据
                        switchTab(filterType);
                    }, LOAD_THROTTLE_MS);
                }
            });
        }

        // 设置滚动监听，实现分页加载
        if (parkingListScroll != null) {
            parkingListScroll.setReboundEffect(false);
            // 监听滚动到底部
            parkingListScroll.addScrolledListener(new Component.ScrolledListener() {
                @Override
                public void onContentScrolled(Component component, int x, int y, int oldX, int oldY) {
                    // 防抖：避免频繁触发
                    long currentTime = System.currentTimeMillis();
                    if (currentTime - lastLoadTime < LOAD_THROTTLE_MS) {
                        return;
                    }

                    // 如果正在加载或没有更多数据，直接返回
                    if (isLoading || !hasMore) {
                        return;
                    }

                    // 计算是否滚动到底部
                    int scrollY = parkingListScroll.getScrollValue(1);
                    int viewHeight = parkingListScroll.getHeight();

                    // 获取内容高度（使用容器的高度）
                    int contentHeight = 0;
                    if (parkingListContainer != null) {
                        contentHeight = parkingListContainer.getHeight();
                    }

                    // 如果容器高度为0，尝试使用EstimatedHeight
                    if (contentHeight == 0) {
                        contentHeight = parkingListScroll.getEstimatedHeight();
                    }

                    // 如果内容高度或视图高度为0，无法计算，直接返回
                    if (contentHeight == 0 || viewHeight == 0) {
                        return;
                    }

                    // 计算剩余滚动距离
                    int remainingDistance = contentHeight - scrollY - viewHeight;

                    // 计算阈值（50像素，约等于50vp），当剩余距离小于等于阈值时触发加载
                    int threshold = 50;

                    // 当滚动到底部（剩余距离小于等于阈值）时，触发加载
                    if (remainingDistance <= threshold && remainingDistance >= 0) {
                        lastLoadTime = currentTime;
                        // 加载下一页
                        loadParkingData(false);
                    }
                }
            });
        }
    }

    /**
     * 切换标签页
     */
    private void switchTab(int filter) {
        filterType = filter;
        currentPage = 1;
        hasMore = true;
        lastLoadTime = 0; // 重置防抖时间
        parkingList.clear();
        if (parkingListContainer != null) {
            parkingListContainer.removeAllComponents();
        }
        // 清除选中状态
        selectedParkingItem = null;

        // 加载数据
        loadParkingData(true);
    }

    /**
     * 显示距离筛选下拉对话框
     */
    private void showDistanceFilterDialog() {
        String[] options = {"500m", "1km", "3km"};
        int[] values = {500, 1000, 3000};
        
        // 找到当前选中的索引
        int currentIndex = -1;
        for (int i = 0; i < values.length; i++) {
            if (values[i] == selectedDistance) {
                currentIndex = i;
                break;
            }
        }
        
        CustomListDialog listDialog = DialogUtil.createListDialog(context, options, (iDialog, index) -> {
            selectedDistance = values[index];
            if (btnDistanceFilter != null && btnDistanceFilter.getChildCount() > 0) {
                Component textComponent = btnDistanceFilter.getComponentAt(0);
                if (textComponent instanceof Text) {
                    ((Text) textComponent).setText(options[index]);
                }
            }
            // 重新加载数据
            switchTab(filterType);
            iDialog.destroy();
        });
        
        // 设置当前选中项
        if (currentIndex >= 0) {
            listDialog.setSelectedIndex(currentIndex);
        }
        
        listDialog.show();
    }

    /**
     * 显示排序方式下拉对话框
     */
    private void showSortFilterDialog() {
        String[] options = {"车位最多", "距离最近", "免费时长最长"};
        int[] values = {1, 2, 3};
        
        // 找到当前选中的索引
        int currentIndex = -1;
        for (int i = 0; i < values.length; i++) {
            if (values[i] == selectedFilter) {
                currentIndex = i;
                break;
            }
        }
        
        CustomListDialog listDialog = DialogUtil.createListDialog(context, options, (iDialog, index) -> {
            selectedFilter = values[index];
            if (btnDistanceSort != null && btnDistanceSort.getChildCount() > 0) {
                Component textComponent = btnDistanceSort.getComponentAt(0);
                if (textComponent instanceof Text) {
                    ((Text) textComponent).setText(options[index]);
                }
            }
            // 重新加载数据
            switchTab(filterType);
            iDialog.destroy();
        });
        
        // 设置当前选中项
        if (currentIndex >= 0) {
            listDialog.setSelectedIndex(currentIndex);
        }
        
        listDialog.show();
    }

    /**
     * 加载停车场数据
     */
    private void loadParkingData(boolean isRefresh) {
        if (isLoading) {
            return;
        }

        if (isRefresh) {
            currentPage = 1;
            hasMore = true;
            lastLoadTime = 0; // 重置防抖时间
            parkingList.clear();
            if (parkingListContainer != null) {
                parkingListContainer.removeAllComponents();
            }
        }

        if (!hasMore) {
            return;
        }

        // 锁定当前页码，避免并发问题
        final int requestPage = currentPage;
        isLoading = true;

        // 获取定位坐标
        double latitude = 0;
        double longitude = 0;
        if (currentLocation != null) {
            latitude = currentLocation.getLatitude();
            longitude = currentLocation.getLongitude();
        }

        // 获取车场名称输入框的值
        String parkName = "";
        if (inputParkName != null) {
            String inputText = inputParkName.getText();
            if (inputText != null && !inputText.trim().isEmpty()) {
                try {
                    parkName = URLEncoder.encode(inputText.trim(), "UTF-8");
                } catch (Exception e) {
                    parkName = inputText.trim();
                }
            }
        }

        // 构建请求URL（使用锁定的页码）
        ApiOption option = new ApiOption();
        option.setUrl(String.format("/park/near/page?type=%d&filter=%d&latitude=%f&longitude=%f&current=%d&size=%d&parkName=%s",
                filterType, selectedFilter, latitude, longitude, requestPage, pageSize, parkName));
        option.setMethod(ApiOption.GET);

        // 发送请求（网络请求已在后台线程）
        CompletableFuture<R<Page<ParkNearRes>>> future = api.http(context, option, new TypeToken<R<Page<ParkNearRes>>>(){});
        if (loadingComponent != null) {
            loadingComponent.show();
        }
        future.thenAccept(response -> {
            // 在后台线程解析数据，避免阻塞UI
            try {
                if (response == null || !response.isSuccess()) {
                    String errorMsg = response != null ? response.getMsg() : "请求失败";
                    Log.error("加载停车场数据失败: " + errorMsg);
                    return;
                }

                // 解析响应数据（在后台线程）
                Object dataObj = response.getData();
                Page<ParkNearRes> page = null;
                if (dataObj != null) {
                    Gson gson = new Gson();
                    Type pageType = new TypeToken<Page<ParkNearRes>>(){}.getType();
                    String dataJson = gson.toJson(dataObj);
                    page = gson.fromJson(dataJson, pageType);
                }
                if (page == null) {
                    Log.error("响应数据为空");
                    return;
                }

                // 解析Page对象（在后台线程）
                if (page == null || page.getRecords() == null) {
                    Log.error("解析分页数据失败");
                    return;
                }

                List<ParkNearRes> records = page.getRecords();
                if (records.isEmpty()) {
                    hasMore = false;
                    return;
                }

                // 更新分页信息（在后台线程计算）
                boolean hasMoreData = true;
                int nextPage = requestPage + 1;
                if (page.getCurrent() != null && page.getPages() != null) {
                    int serverCurrent = page.getCurrent();
                    int totalPages = page.getPages();
                    if (serverCurrent >= totalPages) {
                        hasMoreData = false;
                    } else {
                        // 使用服务器返回的current值+1作为下一页
                        nextPage = serverCurrent + 1;
                    }
                } else {
                    if (records.size() < pageSize) {
                        hasMoreData = false;
                    }
                }

                // 保存最终的分页信息
                final boolean finalHasMore = hasMoreData;
                final int finalNextPage = nextPage;
                final List<ParkNearRes> finalRecords = records;

                // 只在UI线程更新界面
                new EventHandler(EventRunner.getMainEventRunner()).postTask(() -> {
                    // 检查currentPage是否已经被其他请求更新（防止旧请求覆盖新数据）
                    if (currentPage > requestPage) {
                        Log.info("忽略过期请求，当前页码: " + currentPage + ", 请求页码: " + requestPage);
                        return;
                    }

                    // 添加到列表
                    parkingList.addAll(finalRecords);

                    // 批量渲染列表项（减少UI更新次数，延迟批量添加）
                    if (parkingListContainer != null && !finalRecords.isEmpty()) {
                        // 先批量创建所有组件
                        List<Component> items = new ArrayList<>();
                        for (ParkNearRes park : finalRecords) {
                            Component item = createParkingItem(park);
                            if (item != null) {
                                items.add(item);
                            }
                        }

                        // 批量添加到容器（减少UI重绘次数）
                        for (Component item : items) {
                            parkingListContainer.addComponent(item);
                        }
                    }

                    // 更新分页信息
                    hasMore = finalHasMore;
                    if (finalHasMore) {
                        currentPage = finalNextPage;
                    }
                });

            } catch (Exception e) {
                Log.error("解析停车场数据失败: " + e.getMessage());
                e.printStackTrace();
            } finally {
                isLoading = false;
                if (loadingComponent != null) {
                    loadingComponent.hide();
                }
            }
        });
    }

    /**
     * 创建停车场列表项组件（不添加到容器）
     */
    private Component createParkingItem(ParkNearRes park) {
        if (parkingListContainer == null) {
            return null;
        }

        try {
            // 使用 ParkingItemComponent 组件
            ParkItemComponent item = new ParkItemComponent(context, park);
            
            // 设置选中监听器，实现全局选中状态管理
            item.setOnItemSelectedListener(new ParkItemComponent.OnItemSelectedListener() {
                @Override
                public void onItemSelected(ParkItemComponent component, ParkNearRes parkData) {
                    // 如果之前有选中的项，取消其选中状态
                    if (selectedParkingItem != null && selectedParkingItem != component) {
                        selectedParkingItem.setSelected(false);
                    }
                    // 更新当前选中的项
                    selectedParkingItem = component;
                    // 通知外部监听器
                    if (onParkSelectedListener != null) {
                        onParkSelectedListener.onParkSelected(parkData);
                    }
                }

                @Override
                public void onItemDeselected(ParkItemComponent component) {
                    // 如果取消的是当前选中的项，清除选中状态
                    if (selectedParkingItem == component) {
                        selectedParkingItem = null;
                    }
                    // 通知外部监听器
                    if (onParkSelectedListener != null) {
                        onParkSelectedListener.onParkDeselected();
                    }
                }
            });

            return item;

        } catch (Exception e) {
            Log.error("创建停车场列表项失败: " + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 设置当前定位坐标
     */
    public void setCurrentLocation(Location location) {
        this.currentLocation = location;
        // 如果已有定位，重新加载数据
        if (location != null) {
            loadParkingData(true);
        }
    }

    /**
     * 设置Loading组件
     */
    public void setLoadingComponent(LoadingComponent loadingComponent) {
        this.loadingComponent = loadingComponent;
    }

    /**
     * 刷新数据
     */
    public void refresh() {
        loadParkingData(true);
    }

    /**
     * 设置停车场选中监听器
     */
    public void setOnParkSelectedListener(OnParkSelectedListener listener) {
        this.onParkSelectedListener = listener;
    }
}

