package com.fujica.abk.utils;

import com.fujica.abk.ResourceTable;
import ohos.agp.animation.Animator;
import ohos.agp.animation.AnimatorProperty;
import ohos.agp.components.AttrSet;
import ohos.agp.components.Component;
import ohos.agp.components.ComponentContainer;
import ohos.agp.components.DirectionalLayout;
import ohos.agp.components.Image;
import ohos.agp.components.LayoutScatter;
import ohos.agp.components.ProgressBar;
import ohos.agp.utils.Color;
import ohos.agp.utils.LayoutAlignment;
import ohos.app.Context;
import ohos.eventhandler.EventHandler;
import ohos.eventhandler.EventRunner;

/**
 * Loading组件类，继承DirectionalLayout
 * 全屏遮罩，中间显示loading，不可点击，不可取消
 * 使用方式：在 AbilitySlice 中定义为属性，初始化后添加到根布局
 */
public class LoadingComponent extends DirectionalLayout {
    private Component contentLayout;
    private Image loadingImage;
    private AnimatorProperty rotationAnimator;

    /**
     * 构造函数（用于代码创建）
     */
    public LoadingComponent(Context context) {
        super(context);
        initComponent(context);
    }

    /**
     * 构造函数（用于XML布局文件）
     */
    public LoadingComponent(Context context, AttrSet attrSet) {
        super(context, attrSet);
        initComponent(context);
    }

    /**
     * 构造函数（用于XML布局文件，带样式）
     */
    public LoadingComponent(Context context, AttrSet attrSet, String styleName) {
        super(context, attrSet, styleName);
        initComponent(context);
    }

    private void initComponent(Context context) {
        // 设置全屏布局属性
        setWidth(ComponentContainer.LayoutConfig.MATCH_PARENT);
        setHeight(ComponentContainer.LayoutConfig.MATCH_PARENT);
        setAlignment(LayoutAlignment.CENTER);
        setOrientation(VERTICAL);
        
        // 使用布局文件加载内容
        contentLayout = LayoutScatter.getInstance(context)
                .parse(ResourceTable.Layout_layout_loading_dialog, null, false);

        // 将内容布局添加到根布局中
        addComponent(contentLayout);
        
        // 获取图片组件
        Component imageComponent = contentLayout.findComponentById(ResourceTable.Id_loading_image);
        if (imageComponent instanceof Image) {
            loadingImage = (Image) imageComponent;
            // 创建旋转动画
            initRotationAnimation();
        }
        
        // 默认隐藏
        setVisibility(HIDE);
    }
    
    /**
     * 初始化旋转动画
     */
    private void initRotationAnimation() {
        if (loadingImage == null) {
            return;
        }
        
        // 先设置初始旋转角度为0
        loadingImage.setRotation(0f);
        
        // 创建旋转动画属性
        rotationAnimator = loadingImage.createAnimatorProperty();
        // 设置旋转动画（从当前位置旋转360度）
        rotationAnimator.rotate(360f);
        // 设置动画持续时间（2秒）
        rotationAnimator.setDuration(2000);
        // 不设置无限循环，而是通过监听器手动控制
        rotationAnimator.setLoopedCount(1);
        // 设置动画曲线为线性（匀速旋转）
        rotationAnimator.setCurveType(Animator.CurveType.LINEAR);
        
        // 添加动画状态监听器，在每次动画结束后重新启动
        rotationAnimator.setStateChangedListener(new Animator.StateChangedListener() {
            @Override
            public void onStart(Animator animator) {
            }
            
            @Override
            public void onStop(Animator animator) {
            }
            
            @Override
            public void onCancel(Animator animator) {
            }
            
            @Override
            public void onEnd(Animator animator) {
                // 每次动画结束时重置旋转角度为0，然后重新启动
                if (loadingImage != null && rotationAnimator != null && getVisibility() == VISIBLE) {
                    loadingImage.setRotation(0f);
                    // 延迟一小段时间后重新启动动画，实现连续旋转
                    EventHandler mainHandler = new EventHandler(EventRunner.getMainEventRunner());
                    mainHandler.postTask(() -> {
                        if (rotationAnimator != null && loadingImage != null && getVisibility() == VISIBLE) {
                            rotationAnimator.start();
                        }
                    }, 10);
                }
            }
            
            @Override
            public void onPause(Animator animator) {
            }
            
            @Override
            public void onResume(Animator animator) {
            }
        });
    }
    
    /**
     * 显示Loading
     */
    public void show() {
        setVisibility(VISIBLE);
        // 延迟启动旋转动画，确保组件已完全渲染
        EventHandler mainHandler = new EventHandler(EventRunner.getMainEventRunner());
        mainHandler.postTask(() -> {
            if (rotationAnimator != null && loadingImage != null) {
                // 重置旋转角度
                loadingImage.setRotation(0f);
                // 如果动画正在运行，先停止
                if (rotationAnimator.isRunning()) {
                    rotationAnimator.stop();
                }
                // 启动动画
                rotationAnimator.start();
            }
        }, 100);
    }
    
    /**
     * 隐藏Loading
     */
    public void hide() {
        setVisibility(HIDE);
        // 停止旋转动画
        if (rotationAnimator != null && rotationAnimator.isRunning()) {
            rotationAnimator.stop();
        }
    }
    
    /**
     * 是否正在显示
     */
    public boolean isShowing() {
        return getVisibility() == VISIBLE;
    }
}