package com.wd.speech.manager;

import android.animation.Animator;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.text.Editable;
import android.text.TextWatcher;
import android.view.MotionEvent;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;
import androidx.annotation.ColorRes;
import com.airbnb.lottie.LottieAnimationView;
import com.airbnb.lottie.LottieDrawable;
import com.wd.base.log.Logger;
import com.wd.speech.dialog.VoiceSearchDialog;
import com.wd.speech.R;
import com.wd.speech.SpeechCompServiceImpl;
import com.wd.speech.listener.SpeechResultCallback;
import com.wd.speech.utils.KeyBoardObserver;
import com.wd.speech.utils.KeyboardHelper;
import com.wd.speech.view.BackEditText;
import com.wd.speech.view.MeasureFrameLayout;
import com.wd.common.permissions.IPmsCallBack;
import com.wd.common.permissions.PermissionsUtils;
import com.wd.foundation.wdkit.utils.SpUtils;
import com.wd.foundation.wdkit.utils.ToastNightUtil;
import com.wd.foundation.wdkitcore.thread.ThreadPoolUtils;
import com.wd.foundation.wdkitcore.tools.ResUtils;
import com.wd.foundation.wdkitcore.tools.StringUtils;

/**
 * @author LiuKun
 * @date 2023/5/2  17:24
 * @Description：表情键盘切换
 */
public class ExpressionManager implements KeyBoardObserver {


    private final Activity activity;
    private SpeechCompServiceImpl speechCompService;

    private final View voiceLayout;

    private BackEditText editText;

    private final ImageView voiceBtn;

    /**
     * 是否限制字数
     */
    private boolean isLimit = false;
    private int mMaxInputLength = 1000;
    /**
     * 当文字超出最大值时是否改变提示文字颜色
     */
    private boolean isChangeInputCountColor = false;
    private int[] changeColors;
    private MeasureFrameLayout rootLayout;

    /**
     * 0:show keyboard 1:show voice 2:show expression
     */
    private int showButton = 1;
    // 语音输入的布局
    private FrameLayout flVoiceInput;
    private TextView voiceBottomTip;

    /**
     * 语音输入动画
     */
    private LottieAnimationView lavVoiceInput;
    private LottieAnimationView lavVoiceInputsteptwo;

    /**
     * 是否正在录音
     */
    private boolean isRecording = false;
    private boolean isstart;

    /**
     * 使用类型，0：默认 1：语音搜索
     */
    private int useType = 0;

    private VoiceSearchDialog voiceSearchDialog;

    /**
     * 构造方法
     */
    public ExpressionManager(VoiceSearchDialog voiceSearchDialog,Activity activity, SpeechCompServiceImpl speechCompService,
                             View voiceLayout, BackEditText inputEt, ImageView voiceBtn,int useType) {
        this.voiceSearchDialog = voiceSearchDialog;
        this.activity = activity;
        this.speechCompService  = speechCompService;
        this.voiceLayout = voiceLayout;
        this.editText = inputEt;
        this.voiceBtn = voiceBtn;
        this.useType = useType;
        init();
    }

    /**
     * 初始化
     */
    private void init() {
        initView();
        addListener();
    }

    /**
     * 初始化布局
     */
    private void initView() {
        // 语音输入的布局
        lavVoiceInput = voiceLayout.findViewById(R.id.lavVoiceInput);
        lavVoiceInputsteptwo =  voiceLayout.findViewById(R.id.lavVoiceInputsteptwo);
        voiceBottomTip = voiceLayout.findViewById(R.id.dv_tv_bottom_tip);
        flVoiceInput = voiceLayout.findViewById(R.id.flVoiceInput);
        if(SpUtils.isNightMode()){
            //夜间模式
            lavVoiceInput.setAnimation("voice_input_night.json");
            lavVoiceInputsteptwo.setAnimation("voice_inputsteptwo_night.json");
        }else {
            lavVoiceInput.setAnimation("voice_input.json");
            lavVoiceInputsteptwo.setAnimation("voice_inputsteptwo.json");
        }
        lavVoiceInput.setRepeatCount(0);
        lavVoiceInputsteptwo.setRepeatCount(LottieDrawable.INFINITE);
        lavVoiceInput.addAnimatorListener(new Animator.AnimatorListener() {
            @Override
            public void onAnimationStart(Animator animation) {

            }

            @Override
            public void onAnimationEnd(Animator animation) {
                if(isstart){
                    isstart = false;
                    lavVoiceInput.pauseAnimation();
                    lavVoiceInputsteptwo.setVisibility(View.VISIBLE);
                    lavVoiceInputsteptwo.playAnimation();
                }

            }

            @Override
            public void onAnimationCancel(Animator animation) {

            }

            @Override
            public void onAnimationRepeat(Animator animation) {

            }
        });
    }

    /**
     * 开始动画
     */
    private void startVoiceInputAnimation() {
        isstart = true;
        lavVoiceInputsteptwo.setVisibility(View.GONE);
        lavVoiceInputsteptwo.cancelAnimation();
        lavVoiceInputsteptwo.setProgress(0f);
        lavVoiceInput.playAnimation();
    }

    /**
     * 清除动画
     */
    private void stopVoiceInputAnimation() {
        isstart = false;
        lavVoiceInput.setVisibility(View.VISIBLE);
        lavVoiceInputsteptwo.setVisibility(View.GONE);
        lavVoiceInput.cancelAnimation();
        lavVoiceInput.setProgress(0f);
    }

    public void setMaxCountLength(int maxCountLength) {
        this.mMaxInputLength = maxCountLength;
        isLimit = true;
    }

    public void setChangeInputCountColor(@ColorRes int defaultColor, @ColorRes int changeColor) {
        isChangeInputCountColor = true;
        changeColors = new int[]{defaultColor, changeColor};
    }

    /**
     * 语音录制监听
     */
    @SuppressLint("ClickableViewAccessibility")
    private void addListener() {
        /*flVoiceInput.setOnClickListener(view -> {
            if (isRecording) {
                speechCompService.stopSpeech();
            } else {
                speechCompService.beginSpeech();
            }
        });*/

        flVoiceInput.setOnLongClickListener(new View.OnLongClickListener() {
            @Override
            public boolean onLongClick(View v) {
                //长按输入
                if (!isRecording) {
                    speechCompService.beginSpeech();
                }
                return true;
            }
        });

        flVoiceInput.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                if(event.getAction() == MotionEvent.ACTION_UP){
                    //松开停止
                    if (isRecording) {
                        speechCompService.stopSpeech();
                    }
                }
                return false;
            }
        });

        //输入框
        editText.addTextChangedListener(mEditInputListener);
        editText.setOnTouchListener((v, event) -> {
            if(useType == 1 && voiceSearchDialog != null){
                speechCompService.stopSpeech();
                KeyboardHelper.showSoftInput(editText);
                voiceSearchDialog.dismiss();
            }else {
                voicePressUpLift();
                voiceBottomTip.setText(ResUtils.getString(R.string.dialog_comment_long_an));
                showButton = 0;
                hideVoice();
                switchIcon();
            }
            return false;
        });

        //语音录入
        voiceBtn.setOnClickListener(v -> {
            if(useType == 1 && voiceSearchDialog != null){
                speechCompService.stopSpeech();
                KeyboardHelper.showSoftInput(editText);
                voiceSearchDialog.dismiss();
            }else {
                voicePressUpLift();
                checkPermission();
            }
        });


        // 语音输入监听
        speechCompService.setResultCallback(new SpeechResultCallback() {
            @Override
            public void start() {
                ThreadPoolUtils.postToMain(() -> {
                    Logger.t("ExpressionManager").d("识别开始");
                    isRecording = true;
                    voiceBottomTip.setText(R.string.dialog_comment_stop_tips);
                    startVoiceInputAnimation();
                });
            }

            @Override
            public void stop() {
                ThreadPoolUtils.postToMain(() -> {
                    voicePressUpLift();
                    if(StringUtils.isEmpty(editText.getText().toString())){
                        voiceBottomTip.setText(ResUtils.getString(R.string.str_no_voice_recognized_tips));
                    }else {
                        voiceBottomTip.setText(ResUtils.getString(R.string.dialog_comment_long_an));
                    }
                    Logger.t("ExpressionManager").d("识别暂停");
                });
            }

            @Override
            public void error() {
                ThreadPoolUtils.postToMain(() -> {
                    voicePressUpLift();
                    voiceBottomTip.setText(ResUtils.getString(R.string.str_no_voice_recognized_tips));
                });
            }

            @Override
            public void result(String result) {
                ThreadPoolUtils.postToMain(() -> {
                    appendString(result);
                    voicePressUpLift();
                    voiceBottomTip.setText(ResUtils.getString(R.string.dialog_comment_long_an));
                });
            }
        });

    }

    /**
     * 追加文字
     */
    private void appendString(String text) {
        int start = editText.getSelectionStart();
        int end = editText.getSelectionEnd();
        if (start == end) {
            editText.getEditableText().insert(start, text);
        } else {
            editText.getEditableText().replace(start, end, text);
        }
    }

    /**
     * 获取权限，保存图片
     */
    private void checkPermission() {
        PermissionsUtils.getRecordAudio(activity, new IPmsCallBack() {
            @Override
            public void granted() {
                clickVoice();
            }

            @Override
            public void notGranted() {
//                ToastNightUtil.showShort("没有权限或拒绝权限");
            }
        });
    }

    /**
     * 点击语音输入
     */
    private void clickVoice() {
        if (rootLayout == null) {

            if (isVoiceVisible()) {
                showButton = 0;
                switchIcon();
                hideVoice();
                KeyboardHelper.showSoftInput(editText);
            } else {
                showButton = 1;
                KeyboardHelper.hideSoftInput(editText);
                switchIcon();
                showVoice();
            }
        } else {
            if (showButton == 1) {
                showButton = 0;
                KeyboardHelper.showSoftInput(editText);
                switchIcon();
            } else if (showButton == 2) {
                showButton = 1;
                switchIcon();
                showVoice();
            } else {
                showButton = 1;
                if (rootLayout.getKeyBoardObservable().isKeyBoardVisibility()) {
                    switchIcon();
                    KeyboardHelper.hideSoftInput(editText);
                } else {
                    showVoice();
                    switchIcon();
                }
            }
        }
    }

    private void showVoice() {
        if (voiceLayout.getVisibility() == View.GONE) {
            voiceLayout.setVisibility(View.VISIBLE);
        }
    }

    private boolean isVoiceVisible() {
        return voiceLayout.getVisibility() == View.VISIBLE;
    }

    private void hideVoice() {
        if (voiceLayout.getVisibility() == View.VISIBLE) {
            voiceLayout.setVisibility(View.GONE);
        }
    }

    /**
     * 切换按钮
     */
    public void switchIcon() {
        if (showButton == 1) {
            voiceBtn.setImageResource(R.drawable.ic_comment_select_keyboard);
        } else if (showButton == 2) {
            voiceBtn.setImageResource(R.drawable.ic_comment_sound_recording);
        } else {
            voiceBtn.setImageResource(R.drawable.ic_comment_sound_recording);
        }
    }

    /**
     * 停止动画
     */
    public void voicePressUpLift() {
        isRecording = false;
        stopVoiceInputAnimation();
    }

    private boolean isCutText = false;

    /**
     * 输入框监听
     */
    private final TextWatcher mEditInputListener = new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {

        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            if (!isLimit) {
                return;
            }

            // 判断一下，否则　超出最大值会截取，截取后重新赋值还会走这个方法
            if (isCutText) {
                isCutText = false;
                return;
            }

            String text = editText.getText().toString().trim();
            int length = 0;
            boolean isEmoji;
            for (int i = 0; i < text.length(); ) {
                isEmoji = false;
                if (!isEmojiCharacter(text.charAt(i))) {
                    i++;
                    length += 11;
                    isEmoji = true;
                }
                i++;
                length++;
                if (length > mMaxInputLength) {
                    ToastNightUtil.showShort("已达到输入上限");

                    isCutText = true;

                    int cutOutLength = i - 1;
                    if (isEmoji) {
                        cutOutLength = i - 2;
                    }
                    int endSelect = editText.getSelectionEnd();
                    String newStr = text.substring(0, cutOutLength);
                    editText.setText(newStr);
                    if (endSelect > cutOutLength) {
                        endSelect = cutOutLength;
                    }
                    editText.setSelection(endSelect);
                    break;
                }
            }
        }

        @Override
        public void afterTextChanged(Editable s) {

            if (inputTextListener != null) {
                inputTextListener.changed();
            }
        }
    };

    private InputTextListener inputTextListener;

    public void setInputTextListener(InputTextListener inputTextListener) {
        this.inputTextListener = inputTextListener;
    }

    /**
     * 监听输入变化
     */
    public interface InputTextListener {
        void changed();
    }

    private boolean isEmojiCharacter(char codePoint) {
        return (codePoint == 0x0) || (codePoint == 0x9) || (codePoint == 0xA) ||
                (codePoint == 0xD) || ((codePoint >= 0x20) && (codePoint <= 0xD7FF)) ||
                ((codePoint >= 0xE000) && (codePoint <= 0xFFFD)) || ((codePoint >= 0x10000) && (codePoint <= 0x10FFFF));
    }

    @Override
    public void update(boolean keyBoardVisibility, int keyBoardHeight) {

    }

}