/*
 * This is the source code of Telegram for Android v. 5.x.x.
 * It is licensed under GNU GPL v. 2 or later.
 * You should have received a copy of the license in this archive (see LICENSE).
 *
 * Copyright Nikolai Kudashov, 2013-2018.
 */

package org.telegram.ui.Components;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.GradientDrawable;
import android.os.Build;
import android.os.SystemClock;
import android.transition.AutoTransition;
import android.transition.Transition;
import android.transition.TransitionManager;
import android.transition.TransitionSet;
import android.transition.TransitionValues;
import android.util.SparseArray;
import android.util.TypedValue;
import android.view.Gravity;
import android.view.HapticFeedbackConstants;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.HorizontalScrollView;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;

import org.telegram.messenger.AndroidUtilities;
import org.telegram.messenger.DocumentObject;
import org.telegram.messenger.Emoji;
import org.telegram.messenger.FileLoader;
import org.telegram.messenger.ImageLocation;
import org.telegram.messenger.MessageObject;
import org.telegram.messenger.R;
import org.telegram.messenger.SvgHelper;
import org.telegram.tgnet.TLObject;
import org.telegram.tgnet.TLRPC;
import org.telegram.ui.ActionBar.Theme;

import java.util.HashMap;

public class ScrollSlidingTabStrip extends HorizontalScrollView {

    public interface ScrollSlidingTabStripDelegate {
        void onPageSelected(int page);
    }

    public enum Type {
        LINE, TAB
    }

    private Type type = Type.LINE;
    private LinearLayout.LayoutParams defaultTabLayoutParams;
    private LinearLayout.LayoutParams defaultExpandLayoutParams;
    private LinearLayout tabsContainer;
    private ScrollSlidingTabStripDelegate delegate;
    private HashMap<String, View> tabTypes = new HashMap<>();
    private HashMap<String, View> prevTypes = new HashMap<>();
    private SparseArray<View> futureTabsPositions = new SparseArray<>();

    View draggingView;
    float draggingViewOutProgress;
    float draggingViewIndicatorOutProgress;

    private boolean shouldExpand;

    private int tabCount;

    private int currentPosition;
    private boolean animateFromPosition;
    private float startAnimationPosition;
    private float positionAnimationProgress;
    private long lastAnimationTime;
    private float touchSlop;

    private Paint rectPaint;

    private int indicatorColor = 0xff666666;
    private int underlineColor = 0x1a000000;
    private int indicatorHeight;
    private GradientDrawable indicatorDrawable = new GradientDrawable();

    private int scrollOffset = AndroidUtilities.dp(52);
    private int underlineHeight = AndroidUtilities.dp(2);
    private int dividerPadding = AndroidUtilities.dp(12);
    private int tabPadding = AndroidUtilities.dp(24);

    private int lastScrollX = 0;
    private final Theme.ResourcesProvider resourcesProvider;

    SparseArray<StickerTabView> currentPlayingImages = new SparseArray<>();
    SparseArray<StickerTabView> currentPlayingImagesTmp = new SparseArray<>();
    private boolean dragEnabled;
    int startDragFromPosition;
    int currentDragPosition;
    float startDragFromX;
    float dragDx;
    float pressedX;
    float pressedY;
    boolean longClickRunning;

    float draggindViewXOnScreen;
    float draggindViewDxOnScreen;
    Runnable longClickRunnable = new Runnable() {
        @Override
        public void run() {
            longClickRunning = false;
            startDragFromX = getScrollX() + pressedX;
            dragDx = 0;

            int p = (int) Math.ceil(startDragFromX / getTabSize()) - 1;
            startDragFromPosition = currentDragPosition = p;
            if (!canSwap(p)) {
                return;
            }
            if (p >= 0 && p < tabsContainer.getChildCount()) {
                performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
                draggindViewDxOnScreen = 0f;
                draggingViewOutProgress = 0f;
                draggingView = tabsContainer.getChildAt(p);
                draggindViewXOnScreen = draggingView.getX() - getScrollX();
                draggingView.invalidate();
                tabsContainer.invalidate();
                invalidateOverlays();
                invalidate();
            }
        }
    };

    public ScrollSlidingTabStrip(Context context, Theme.ResourcesProvider resourcesProvider) {
        super(context);
        this.resourcesProvider = resourcesProvider;
        touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();

        setFillViewport(true);
        setWillNotDraw(false);

        setHorizontalScrollBarEnabled(false);
        tabsContainer = new LinearLayout(context) {

            @Override
            protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
                if (child instanceof StickerTabView) {
                    ((StickerTabView) child).updateExpandProgress(expandProgress);
                }
                if (child == draggingView) {
                    return true;
                }
                return super.drawChild(canvas, child, drawingTime);
            }
        };
        tabsContainer.setOrientation(LinearLayout.HORIZONTAL);
        tabsContainer.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
        addView(tabsContainer);

        rectPaint = new Paint();
        rectPaint.setAntiAlias(true);
        rectPaint.setStyle(Style.FILL);

        defaultTabLayoutParams = new LinearLayout.LayoutParams(AndroidUtilities.dp(52), LayoutHelper.MATCH_PARENT);
        defaultExpandLayoutParams = new LinearLayout.LayoutParams(0, ViewGroup.LayoutParams.MATCH_PARENT, 1.0F);
    }

    public void setDelegate(ScrollSlidingTabStripDelegate scrollSlidingTabStripDelegate) {
        delegate = scrollSlidingTabStripDelegate;
    }

    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        if (type != null && this.type != type) {
            this.type = type;
            switch (type) {
                case LINE:
                    indicatorDrawable.setCornerRadius(0);
                    break;
                case TAB:
                    float rad = AndroidUtilities.dpf2(3);
                    indicatorDrawable.setCornerRadii(new float[]{rad, rad, rad, rad, 0, 0, 0, 0});
                    break;
            }
        }
    }

    public void removeTabs() {
        tabsContainer.removeAllViews();
        tabTypes.clear();
        prevTypes.clear();
        futureTabsPositions.clear();
        tabCount = 0;
        currentPosition = 0;
        animateFromPosition = false;
    }

    public void beginUpdate(boolean animated) {
        prevTypes = tabTypes;
        tabTypes = new HashMap<>();
        futureTabsPositions.clear();
        tabCount = 0;
        if (animated && Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            final AutoTransition transition = new AutoTransition();
            transition.setDuration(250);
            transition.setOrdering(TransitionSet.ORDERING_TOGETHER);
            transition.addTransition(new Transition() {
                @Override
                public void captureStartValues(TransitionValues transitionValues) {
                }

                @Override
                public void captureEndValues(TransitionValues transitionValues) {
                }

                @Override
                public Animator createAnimator(ViewGroup sceneRoot, TransitionValues startValues, TransitionValues endValues) {
                    final ValueAnimator invalidateAnimator = ValueAnimator.ofFloat(0, 1);
                    invalidateAnimator.addUpdateListener(a -> invalidate());
                    return invalidateAnimator;
                }
            });
            TransitionManager.beginDelayedTransition(tabsContainer, transition);
        }
    }

    public void commitUpdate() {
        if (prevTypes != null) {
            for (HashMap.Entry<String, View> entry : prevTypes.entrySet()) {
                tabsContainer.removeView(entry.getValue());
            }
            prevTypes.clear();
        }
        for (int a = 0, N = futureTabsPositions.size(); a < N; a++) {
            int index = futureTabsPositions.keyAt(a);
            View view = futureTabsPositions.valueAt(a);
            int currentIndex = tabsContainer.indexOfChild(view);
            if (currentIndex != index) {
                tabsContainer.removeView(view);
                tabsContainer.addView(view, index);
            }
        }
        futureTabsPositions.clear();
    }

    public void selectTab(int num) {
        if (num < 0 || num >= tabCount) {
            return;
        }
        View tab = tabsContainer.getChildAt(num);
        tab.performClick();
    }

    private void checkViewIndex(String key, View view, int index) {
        if (prevTypes != null) {
            prevTypes.remove(key);
        }
        futureTabsPositions.put(index, view);
    }

    public TextView addIconTabWithCounter(int id, Drawable drawable) {
        String key = "textTab" + id;
        final int position = tabCount++;

        FrameLayout tab = (FrameLayout) prevTypes.get(key);
        TextView textView;
        if (tab != null) {
            textView = (TextView) tab.getChildAt(1);
            checkViewIndex(key, tab, position);
        } else {
            tab = new FrameLayout(getContext());
            tab.setFocusable(true);
            tabsContainer.addView(tab, position);

            ImageView imageView = new ImageView(getContext());
            imageView.setImageDrawable(drawable);
            imageView.setScaleType(ImageView.ScaleType.CENTER);
            tab.setOnClickListener(v -> delegate.onPageSelected((Integer) v.getTag(R.id.index_tag)));
            tab.addView(imageView, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));

            textView = new TextView(getContext());
            textView.setTypeface(AndroidUtilities.getTypeface("fonts/rmedium.ttf"));
            textView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, 12);
            textView.setTextColor(getThemedColor(Theme.key_chat_emojiPanelBadgeText));
            textView.setGravity(Gravity.CENTER);
            textView.setBackgroundDrawable(Theme.createRoundRectDrawable(AndroidUtilities.dp(9), getThemedColor(Theme.key_chat_emojiPanelBadgeBackground)));
            textView.setMinWidth(AndroidUtilities.dp(18));
            textView.setPadding(AndroidUtilities.dp(5), 0, AndroidUtilities.dp(5), AndroidUtilities.dp(1));
            tab.addView(textView, LayoutHelper.createFrame(LayoutHelper.WRAP_CONTENT, 18, Gravity.TOP | Gravity.LEFT, 26, 6, 0, 0));
        }
        tab.setTag(R.id.index_tag, position);
        tab.setSelected(position == currentPosition);

        tabTypes.put(key, tab);
        return textView;
    }

    public ImageView addIconTab(int id, Drawable drawable) {
        String key = "tab" + id;
        final int position = tabCount++;

        ImageView tab = (ImageView) prevTypes.get(key);
        if (tab != null) {
            checkViewIndex(key, tab, position);
        } else {
            tab = new ImageView(getContext());
            tab.setFocusable(true);
            tab.setImageDrawable(drawable);
            tab.setScaleType(ImageView.ScaleType.CENTER);
            tab.setOnClickListener(v -> delegate.onPageSelected((Integer) v.getTag(R.id.index_tag)));
            tabsContainer.addView(tab, position);
        }
        tab.setTag(R.id.index_tag, position);
        tab.setSelected(position == currentPosition);

        tabTypes.put(key, tab);
        return tab;
    }

    public StickerTabView addStickerIconTab(int id, Drawable drawable) {
        String key = "tab" + id;
        final int position = tabCount++;

        StickerTabView tab = (StickerTabView) prevTypes.get(key);
        if (tab != null) {
            checkViewIndex(key, tab, position);
        } else {
            tab = new StickerTabView(getContext(), StickerTabView.ICON_TYPE);
            tab.iconView.setImageDrawable(drawable);
            tab.setFocusable(true);
            tab.setOnClickListener(v -> delegate.onPageSelected((Integer) v.getTag(R.id.index_tag)));
            tab.setExpanded(expanded);
            tab.updateExpandProgress(expandProgress);
            tabsContainer.addView(tab, position);
        }
        tab.isChatSticker = false;
        tab.setTag(R.id.index_tag, position);
        tab.setSelected(position == currentPosition);

        tabTypes.put(key, tab);
        return tab;
    }

    public void addStickerTab(TLRPC.Chat chat) {
        String key = "chat" + chat.id;
        final int position = tabCount++;

        StickerTabView tab = (StickerTabView) prevTypes.get(key);
        if (tab != null) {
            checkViewIndex(key, tab, position);
        } else {
            StickerTabView stickerTabView = new StickerTabView(getContext(), StickerTabView.STICKER_TYPE);
            tab = stickerTabView;
            tab.setFocusable(true);
            tab.setOnClickListener(v -> delegate.onPageSelected((Integer) v.getTag(R.id.index_tag)));
            tabsContainer.addView(tab, position);
            stickerTabView.setRoundImage();

            AvatarDrawable avatarDrawable = new AvatarDrawable();
            avatarDrawable.setTextSize(AndroidUtilities.dp(14));
            avatarDrawable.setInfo(chat);

            BackupImageView imageView = stickerTabView.imageView;
            imageView.setLayerNum(1);
            imageView.setForUserOrChat(chat, avatarDrawable);
            imageView.setAspectFit(true);

            stickerTabView.setExpanded(expanded);
            stickerTabView.updateExpandProgress(expandProgress);
            stickerTabView.textView.setText(chat.title);
        }
        tab.isChatSticker = true;
        tab.setTag(R.id.index_tag, position);
        tab.setSelected(position == currentPosition);

        tabTypes.put(key, tab);
    }

    public View addEmojiTab(int id, Emoji.EmojiDrawable emojiDrawable, TLRPC.Document emojiSticker) {
        String key = "tab" + id;
        final int position = tabCount++;
        StickerTabView tab = (StickerTabView) prevTypes.get(key);
        if (tab != null) {
            checkViewIndex(key, tab, position);
        } else {
            tab = new StickerTabView(getContext(), StickerTabView.EMOJI_TYPE);
            tab.setFocusable(true);
            tab.setOnClickListener(v -> delegate.onPageSelected((Integer) v.getTag(R.id.index_tag)));

            tab.setExpanded(expanded);
            tab.updateExpandProgress(expandProgress);

            tabsContainer.addView(tab, position);
        }
        tab.isChatSticker = false;
        tab.setTag(R.id.index_tag, position);
        tab.setTag(R.id.parent_tag, emojiDrawable);
        tab.setTag(R.id.object_tag, emojiSticker);
        tab.setSelected(position == currentPosition);

        tabTypes.put(key, tab);
        return tab;
    }

    public View addStickerTab(TLObject thumb, TLRPC.Document sticker, TLRPC.TL_messages_stickerSet parentObject) {
        String key = "set" + (parentObject == null ? sticker.id : parentObject.set.id);
        final int position = tabCount++;

        StickerTabView tab = (StickerTabView) prevTypes.get(key);
        if (tab != null) {
            checkViewIndex(key, tab, position);
        } else {
            tab = new StickerTabView(getContext(), StickerTabView.STICKER_TYPE);
            tab.setFocusable(true);
            tab.setOnClickListener(v -> delegate.onPageSelected((Integer) v.getTag(R.id.index_tag)));

            tab.setExpanded(expanded);
            tab.updateExpandProgress(expandProgress);

            tabsContainer.addView(tab, position);
        }
        tab.isChatSticker = false;
        tab.setTag(thumb);
        tab.setTag(R.id.index_tag, position);
        tab.setTag(R.id.parent_tag, parentObject);
        tab.setTag(R.id.object_tag, sticker);
        tab.setSelected(position == currentPosition);

        tabTypes.put(key, tab);
        return tab;
    }

    boolean expanded = false;
    boolean animateToExpanded;
    ValueAnimator expandStickerAnimator;
    float expandProgress;

    private float stickerTabExpandedWidth = AndroidUtilities.dp(86);
    private float stickerTabWidth = AndroidUtilities.dp(52);
    private float expandOffset;
    private int scrollByOnNextMeasure = -1;

    public void expandStickers(float x, boolean expanded) {
//        if (expandStickerAnimator != null || draggingView != null) {
//            return;
//        }
        if (this.expanded != expanded) {
            this.expanded = expanded;

            if (!expanded) {
                fling(0);
            }

            if (expandStickerAnimator != null) {
                expandStickerAnimator.removeAllListeners();
                expandStickerAnimator.cancel();
            }
            expandStickerAnimator = ValueAnimator.ofFloat(expandProgress, expanded ? 1f : 0f);
            expandStickerAnimator.addUpdateListener(valueAnimator -> {
                if (!expanded) {
                    float allSize = stickerTabWidth * tabsContainer.getChildCount();
                    float totalXRelative = (getScrollX() + x) / (stickerTabExpandedWidth * tabsContainer.getChildCount());
                    float maxXRelative = (allSize - getMeasuredWidth()) / allSize;
                    float additionalX = x;
                    if (totalXRelative > maxXRelative) {
                        totalXRelative = maxXRelative;
                        additionalX = 0;
                    }
                    float scrollToX = allSize * totalXRelative;
                    if (scrollToX - additionalX < 0) {
                        scrollToX = additionalX;
                    }
                    expandOffset = (getScrollX() + additionalX) - scrollToX;
                }
                expandProgress = (float) valueAnimator.getAnimatedValue();
                for (int i = 0; i < tabsContainer.getChildCount(); i++) {
                    tabsContainer.getChildAt(i).invalidate();
                }
                tabsContainer.invalidate();
                updatePosition();
            });
            expandStickerAnimator.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    expandStickerAnimator = null;
                    expandProgress = expanded ? 1f : 0f;
                    for (int i = 0; i < tabsContainer.getChildCount(); i++) {
                        tabsContainer.getChildAt(i).invalidate();
                    }
                    tabsContainer.invalidate();
                    updatePosition();
                    if (!expanded) {
                        float allSize = stickerTabWidth * tabsContainer.getChildCount();
                        float totalXRelative = (getScrollX() + x) / (stickerTabExpandedWidth * tabsContainer.getChildCount());
                        float maxXRelative = (allSize - getMeasuredWidth()) / allSize;
                        float additionalX = x;
                        if (totalXRelative > maxXRelative) {
                            totalXRelative = maxXRelative;
                            additionalX = 0;
                        }
                        float scrollToX = allSize * totalXRelative;
                        if (scrollToX - additionalX < 0) {
                            scrollToX = additionalX;
                        }
                        expandOffset = (getScrollX() + additionalX) - scrollToX;
                        scrollByOnNextMeasure = (int) (scrollToX - additionalX);

                        if (scrollByOnNextMeasure < 0) {
                            scrollByOnNextMeasure = 0;
                        }

                        for (int i = 0; i < tabsContainer.getChildCount(); i++) {
                            View child = tabsContainer.getChildAt(i);
                            if (child instanceof StickerTabView) {
                                ((StickerTabView) child).setExpanded(false);
                            }
                            child.getLayoutParams().width = AndroidUtilities.dp(52);
                        }
                        animateToExpanded = false;
                        getLayoutParams().height = AndroidUtilities.dp(48);
                        tabsContainer.requestLayout();
                    }
                }
            });
            expandStickerAnimator.start();

            if (expanded) {
                animateToExpanded = true;
                for (int i = 0; i < tabsContainer.getChildCount(); i++) {
                    View child = tabsContainer.getChildAt(i);
                    if (child instanceof StickerTabView) {
                        ((StickerTabView) child).setExpanded(true);
                    }
                    child.getLayoutParams().width = AndroidUtilities.dp(86);
                }

                tabsContainer.requestLayout();
                getLayoutParams().height = AndroidUtilities.dp(48 + 50);
            }

            if (expanded) {
                float totalXRelative = (getScrollX() + x) / (stickerTabWidth * tabsContainer.getChildCount());
                float scrollToX = stickerTabExpandedWidth * tabsContainer.getChildCount() * totalXRelative;

                expandOffset = scrollToX - (getScrollX() + x);
                scrollByOnNextMeasure = (int) (scrollToX - x);
            }
        }
    }

    protected void updatePosition() {

    }

    public float getExpandedOffset() {
        return animateToExpanded ? AndroidUtilities.dp(50) * expandProgress : 0;
    }

    public void updateTabStyles() {
        for (int i = 0; i < tabCount; i++) {
            View v = tabsContainer.getChildAt(i);
            if (shouldExpand) {
                v.setLayoutParams(defaultExpandLayoutParams);
            } else {
                v.setLayoutParams(defaultTabLayoutParams);
            }
        }
    }

    private void scrollToChild(int position) {
        if (tabCount == 0 || tabsContainer.getChildAt(position) == null) {
            return;
        }
        int newScrollX = tabsContainer.getChildAt(position).getLeft();
        if (position > 0) {
            newScrollX -= scrollOffset;
        }
        int currentScrollX = getScrollX();
        if (newScrollX != lastScrollX) {
            if (newScrollX < currentScrollX) {
                lastScrollX = newScrollX;
                smoothScrollTo(lastScrollX, 0);
            } else if (newScrollX + scrollOffset > currentScrollX + getWidth() - scrollOffset * 2) {
                lastScrollX = newScrollX - getWidth() + scrollOffset * 3;
                smoothScrollTo(lastScrollX, 0);
            }
        }
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        setImages();
        if (scrollByOnNextMeasure >= 0) {
            scrollTo(scrollByOnNextMeasure, 0);
            scrollByOnNextMeasure = -1;
        }
    }

    public void setImages() {
        float tabSize = AndroidUtilities.dp( 52) + AndroidUtilities.dp(34) * expandProgress;
        float scrollOffset = animateToExpanded ? expandOffset * (1f - expandProgress) : 0;
        int start = (int) ((getScrollX() - scrollOffset) / tabSize);
        int end = Math.min(tabsContainer.getChildCount(), start + (int) Math.ceil(getMeasuredWidth() / tabSize) + 1);
        if (animateToExpanded) {
            start -= 2;
            end += 2;
            if (start < 0) {
                start = 0;
            }
            if (end > tabsContainer.getChildCount()) {
                end = tabsContainer.getChildCount();
            }
        }
        currentPlayingImagesTmp.clear();
        for (int i = 0; i < currentPlayingImages.size(); i++) {
            currentPlayingImagesTmp.put(currentPlayingImages.valueAt(i).index, currentPlayingImages.valueAt(i));
        }
        currentPlayingImages.clear();

        for (int a = start; a < end; a++) {
            View child = tabsContainer.getChildAt(a);
            if (child instanceof StickerTabView) {
                StickerTabView tabView = (StickerTabView) child;
                if (tabView.type == StickerTabView.EMOJI_TYPE) {
                    Object thumb = tabView.getTag(R.id.parent_tag);
                    Object sticker = tabView.getTag(R.id.object_tag);
                    Drawable thumbDrawable = null;
                    if (thumb instanceof Drawable) {
                        thumbDrawable = (Drawable) thumb;
                    }
                    if (sticker instanceof TLRPC.Document) {
                      //  String.format(Locale.US, "%d_%d_nr_%s" + messageObject.emojiAnimatedStickerColor, w, h, messageObject.toString());
                        tabView.imageView.setImage(ImageLocation.getForDocument((TLRPC.Document) sticker), "36_36_nolimit", thumbDrawable, null);
                    } else {
                        tabView.imageView.setImageDrawable(thumbDrawable);
                    }
                } else {
                    Object object = child.getTag();
                    Object parentObject = child.getTag(R.id.parent_tag);
                    TLRPC.Document sticker = (TLRPC.Document) child.getTag(R.id.object_tag);
                    ImageLocation imageLocation;

                    if (object instanceof TLRPC.Document) {
                        TLRPC.PhotoSize thumb = FileLoader.getClosestPhotoSizeWithSize(sticker.thumbs, 90);
                        if (!tabView.inited) {
                            tabView.svgThumb = DocumentObject.getSvgThumb((TLRPC.Document) object, Theme.key_emptyListPlaceholder, 0.2f);
                        }
                        imageLocation = ImageLocation.getForDocument(thumb, sticker);
                    } else if (object instanceof TLRPC.PhotoSize) {
                        TLRPC.PhotoSize thumb = (TLRPC.PhotoSize) object;
                        int thumbVersion = 0;
                        if (parentObject instanceof TLRPC.TL_messages_stickerSet) {
                            thumbVersion = ((TLRPC.TL_messages_stickerSet) parentObject).set.thumb_version;
                        }
                        imageLocation = ImageLocation.getForSticker(thumb, sticker, thumbVersion);
                    } else {
                        continue;
                    }

                    if (imageLocation == null) {
                        continue;
                    }
                    tabView.inited = true;
                    SvgHelper.SvgDrawable svgThumb = tabView.svgThumb;
                    BackupImageView imageView = tabView.imageView;
                    if (object instanceof TLRPC.Document && MessageObject.isAnimatedStickerDocument(sticker, true)) {
                        if (svgThumb != null) {
                            imageView.setImage(ImageLocation.getForDocument(sticker), "40_40", svgThumb, 0, parentObject);
                        } else {
                            imageView.setImage(ImageLocation.getForDocument(sticker), "40_40", imageLocation, null, 0, parentObject);
                        }
                    } else if (imageLocation.imageType == FileLoader.IMAGE_TYPE_LOTTIE) {
                        imageView.setImage(imageLocation, "40_40", "tgs", svgThumb, parentObject);
                    } else {
                        imageView.setImage(imageLocation, null, "webp", svgThumb, parentObject);
                    }
                    String title = null;
                    if (parentObject instanceof TLRPC.TL_messages_stickerSet) {
                        title = ((TLRPC.TL_messages_stickerSet) parentObject).set.title;
                    }
                    tabView.textView.setText(title);
                }
                currentPlayingImages.put(tabView.index, tabView);
                currentPlayingImagesTmp.remove(tabView.index);
            }
        }

        for (int i = 0; i < currentPlayingImagesTmp.size(); i++) {
            StickerTabView stickerTabView = currentPlayingImagesTmp.valueAt(i);
            if (stickerTabView != draggingView) {
                currentPlayingImagesTmp.valueAt(i).imageView.setImageDrawable(null);
            }
        }
    }

    private int getTabSize() {
        return AndroidUtilities.dp(animateToExpanded ? 86 : 52);
    }

    @Override
    protected void onScrollChanged(int l, int t, int oldl, int oldt) {
        super.onScrollChanged(l, t, oldl, oldt);
        setImages();
    }

    @Override
    protected void dispatchDraw(Canvas canvas) {
        float dif = (stickerTabWidth - stickerTabExpandedWidth);
        float offset = expandOffset * (1f - expandProgress);
        for (int i = 0; i < tabsContainer.getChildCount(); i++) {
            if (tabsContainer.getChildAt(i) instanceof StickerTabView) {
                StickerTabView stickerTabView = (StickerTabView) tabsContainer.getChildAt(i);
                stickerTabView.animateIfPositionChanged(this);
                if (animateToExpanded) {
                    stickerTabView.setTranslationX(dif * i * (1f - expandProgress) + offset + stickerTabView.dragOffset);
                } else {
                    stickerTabView.setTranslationX(stickerTabView.dragOffset);
                }
            }
        }

        super.dispatchDraw(canvas);
        if (isInEditMode() || tabCount == 0) {
            return;
        }

        float height = getHeight();
        if (animateToExpanded) {
            height = getHeight() - AndroidUtilities.dp(50) * (1f - expandProgress);
        }

        if (underlineHeight > 0) {
            rectPaint.setColor(underlineColor);
            canvas.drawRect(0, height - underlineHeight, tabsContainer.getWidth(), height, rectPaint);
        }

        if (indicatorHeight >= 0) {
            View currentTab = tabsContainer.getChildAt(currentPosition);
            float lineLeft = 0;
            float width = 0;
            if (currentTab != null) {
                lineLeft = currentTab.getX();
                width = currentTab.getMeasuredWidth();
            }
            if (animateToExpanded) {
                width = stickerTabWidth + (stickerTabExpandedWidth - stickerTabWidth) * expandProgress;
            }
            if (animateFromPosition) {
                long newTime = SystemClock.elapsedRealtime();
                long dt = newTime - lastAnimationTime;
                lastAnimationTime = newTime;

                positionAnimationProgress += dt / 150.0f;
                if (positionAnimationProgress >= 1.0f) {
                    positionAnimationProgress = 1.0f;
                    animateFromPosition = false;
                }
                lineLeft = startAnimationPosition + (lineLeft - startAnimationPosition) * CubicBezierInterpolator.EASE_OUT_QUINT.getInterpolation(positionAnimationProgress);
                invalidate();
            }

            if (draggingView != null && draggingViewIndicatorOutProgress != 1f) {
                draggingViewIndicatorOutProgress += 16 / 150f;
                if (draggingViewIndicatorOutProgress > 1f) {
                    draggingViewIndicatorOutProgress = 1f;
                } else {
                    invalidate();
                }
            } else if (draggingView == null && draggingViewIndicatorOutProgress != 0){
                draggingViewIndicatorOutProgress -= 16 / 150f;
                if (draggingViewIndicatorOutProgress < 0) {
                    draggingViewIndicatorOutProgress = 0;
                } else {
                    invalidate();
                }
            }

            switch (type) {
                case LINE:
                    if (indicatorHeight == 0) {
                        indicatorDrawable.setBounds((int) lineLeft, 0, (int) (lineLeft + width), (int) height);
                    } else {
                        indicatorDrawable.setBounds((int) lineLeft, (int) (height - indicatorHeight), (int) (lineLeft + width), (int) height);
                    }
                    break;
                case TAB:
                    float yOffset = AndroidUtilities.dp(3) * draggingViewIndicatorOutProgress;
                    indicatorDrawable.setBounds((int) lineLeft + AndroidUtilities.dp(6), (int) (height - AndroidUtilities.dp(3) + yOffset), (int) (lineLeft + width - AndroidUtilities.dp(6)), (int) (height + yOffset));
                    break;
            }

            indicatorDrawable.setColor(indicatorColor);
            indicatorDrawable.draw(canvas);
        }
    }

    public void drawOverlays(Canvas canvas) {
        if (draggingView != null) {
            canvas.save();
            float x = draggindViewXOnScreen - draggindViewDxOnScreen;
            if (draggingViewOutProgress > 0) {
                x = x * (1f - draggingViewOutProgress) + (draggingView.getX() - getScrollX()) * draggingViewOutProgress;
            }
            canvas.translate(x, 0);
            draggingView.draw(canvas);
            canvas.restore();
        }
    }

    public void setShouldExpand(boolean value) {
        shouldExpand = value;
        requestLayout();
    }

    public int getCurrentPosition() {
        return currentPosition;
    }

    public void cancelPositionAnimation() {
        animateFromPosition = false;
        positionAnimationProgress = 1.0f;
    }

    public void onPageScrolled(int position, int first) {
        if (currentPosition == position) {
            return;
        }

        View currentTab = tabsContainer.getChildAt(currentPosition);
        if (currentTab != null) {
            startAnimationPosition = currentTab.getLeft();
            positionAnimationProgress = 0.0f;
            animateFromPosition = true;
            lastAnimationTime = SystemClock.elapsedRealtime();
        } else {
            animateFromPosition = false;
        }
        currentPosition = position;
        if (position >= tabsContainer.getChildCount()) {
            return;
        }
        positionAnimationProgress = 0.0f;
        for (int a = 0; a < tabsContainer.getChildCount(); a++) {
            tabsContainer.getChildAt(a).setSelected(a == position);
        }
        if (expandStickerAnimator == null) {
            if (first == position && position > 1) {
                scrollToChild(position - 1);
            } else {
                scrollToChild(position);
            }
        }
        invalidate();
    }

    public void invalidateTabs() {
        for (int a = 0, N = tabsContainer.getChildCount(); a < N; a++) {
            tabsContainer.getChildAt(a).invalidate();
        }
    }

    public void setCurrentPosition(int currentPosition) {
        this.currentPosition = currentPosition;
    }

    public void setIndicatorHeight(int value) {
        indicatorHeight = value;
        invalidate();
    }

    public void setIndicatorColor(int value) {
        indicatorColor = value;
        invalidate();
    }

    public void setUnderlineColor(int value) {
        underlineColor = value;
        invalidate();
    }

    public void setUnderlineColorResource(int resId) {
        underlineColor = getResources().getColor(resId);
        invalidate();
    }

    public void setUnderlineHeight(int value) {
        underlineHeight = value;
        invalidate();
    }

    protected void invalidateOverlays() {

    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        return checkLongPress(ev) || super.onInterceptTouchEvent(ev);
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        return checkLongPress(ev) || super.onTouchEvent(ev);
    }

    public boolean checkLongPress(MotionEvent ev) {
        if (ev.getAction() == MotionEvent.ACTION_DOWN && draggingView == null) {
            longClickRunning = true;
            AndroidUtilities.runOnUIThread(longClickRunnable, 500);
            pressedX = ev.getX();
            pressedY = ev.getY();
        }
        if (longClickRunning && ev.getAction() == MotionEvent.ACTION_MOVE) {
            if (Math.abs(ev.getX() - pressedX) > touchSlop || Math.abs(ev.getY() - pressedY) > touchSlop) {
                longClickRunning = false;
                AndroidUtilities.cancelRunOnUIThread(longClickRunnable);
            }
        }
        if (ev.getAction() == MotionEvent.ACTION_MOVE && draggingView != null) {
            float x = getScrollX() + ev.getX();
            int p = (int) Math.ceil(x / getTabSize()) - 1;
            if (p != currentDragPosition) {
                if (p < currentDragPosition) {
                    while (!canSwap(p) && p != currentDragPosition) {
                        p++;
                    }
                } else {
                    while (!canSwap(p) && p != currentDragPosition) {
                        p--;
                    }
                }
            }
            if (currentDragPosition != p && canSwap(p)) {
                for (int i = 0; i < tabsContainer.getChildCount(); i++) {
                    if (i == currentDragPosition) {
                        continue;
                    }
                    StickerTabView stickerTabView = (StickerTabView) tabsContainer.getChildAt(i);
                    stickerTabView.saveXPosition();
                }

                startDragFromX += (p - currentDragPosition) * getTabSize();
                currentDragPosition = p;
                tabsContainer.removeView(draggingView);
                tabsContainer.addView(draggingView, currentDragPosition);
                invalidate();
            }
            dragDx = x - startDragFromX;
            draggindViewDxOnScreen = pressedX - ev.getX();
            float viewScreenX = ev.getX();
            if (viewScreenX < draggingView.getMeasuredWidth() / 2f) {
                startScroll(false);
            } else if (viewScreenX > getMeasuredWidth() - draggingView.getMeasuredWidth() / 2f) {
                startScroll(true);
            } else {
                stopScroll();
            }
            tabsContainer.invalidate();
            invalidateOverlays();
            return true;
        }
        if (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_CANCEL) {
            stopScroll();
            AndroidUtilities.cancelRunOnUIThread(longClickRunnable);
            if (draggingView != null) {
                if (startDragFromPosition != currentDragPosition) {
                    stickerSetPositionChanged(startDragFromPosition, currentDragPosition);
                }
                ValueAnimator dragViewOutAnimator = ValueAnimator.ofFloat(0, 1f);
                dragViewOutAnimator.addUpdateListener(valueAnimator -> {
                    draggingViewOutProgress = (float) valueAnimator.getAnimatedValue();
                    invalidateOverlays();
                });
                dragViewOutAnimator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        if (draggingView != null) {
                            invalidateOverlays();
                            draggingView.invalidate();
                            tabsContainer.invalidate();
                            invalidate();
                            draggingView = null;
                        }
                    }
                });
                dragViewOutAnimator.start();
            }
            longClickRunning = false;
            invalidateOverlays();
        }
        return false;
    }

    protected void stickerSetPositionChanged(int fromPosition, int toPosition) {
    }

    private boolean canSwap(int p) {
        if (!dragEnabled) {
            return false;
        }
        if (p < 0 || p >= tabsContainer.getChildCount()) {
            return false;
        }
        View child = tabsContainer.getChildAt(p);
        if (child instanceof StickerTabView && ((StickerTabView) child).type == StickerTabView.STICKER_TYPE && !((StickerTabView) child).isChatSticker) {
            return true;
        }
        return false;
    }

    boolean scrollRight;
    long scrollStartTime;
    Runnable scrollRunnable = new Runnable() {
        @Override
        public void run() {
            long currentTime = System.currentTimeMillis() - scrollStartTime;
            int dx;
            if (currentTime < 3000) {
                dx = Math.max(1, AndroidUtilities.dp(1)) * (scrollRight ? 1 : -1);
            } else if (currentTime < 5000) {
                dx = Math.max(1, AndroidUtilities.dp(2)) * (scrollRight ? 1 : -1);
            } else {
                dx = Math.max(1, AndroidUtilities.dp(4)) * (scrollRight ? 1 : -1);
            }

            scrollBy(dx, 0);
            AndroidUtilities.runOnUIThread(scrollRunnable);
        }
    };

    private void startScroll(boolean scrollRight) {
        this.scrollRight = scrollRight;
        if (scrollStartTime <= 0) {
            scrollStartTime = System.currentTimeMillis();
        }
        AndroidUtilities.runOnUIThread(scrollRunnable, 16);
    }

    private void stopScroll() {
        scrollStartTime = -1;
        AndroidUtilities.cancelRunOnUIThread(scrollRunnable);
    }

    boolean isDragging() {
        return draggingView != null;
    }

    @Override
    public void cancelLongPress() {
        super.cancelLongPress();
        longClickRunning = false;
        AndroidUtilities.cancelRunOnUIThread(longClickRunnable);
    }

    public void setDragEnabled(boolean enabled) {
        dragEnabled = enabled;
    }

    private int getThemedColor(String key) {
        Integer color = resourcesProvider != null ? resourcesProvider.getColor(key) : null;
        return color != null ? color : Theme.getColor(key);
    }
}