package cc.winboll.studio.positions.adapters;

/**
 * @Author ZhanGSKen&豆包大模型<zhangsken@qq.com>
 * @Date 2025/09/29 20:25
 * @Describe 位置数据适配器（完全独立，无未知接口依赖，仅用LocationActivity缓存数据）
 */
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.RadioGroup;
import android.widget.TextView;
import android.text.TextUtils;
import androidx.recyclerview.widget.RecyclerView;

import cc.winboll.studio.libappbase.LogUtils;
import cc.winboll.studio.positions.R;
import cc.winboll.studio.positions.models.PositionModel;
import cc.winboll.studio.positions.models.PositionTaskModel;
import cc.winboll.studio.positions.services.MainService;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Java 7 语法适配：
 * 1. 移除 Lambda/方法引用，用匿名内部类替代
 * 2. 集合操作使用迭代器（避免 ConcurrentModificationException）
 * 3. 弱引用管理 MainService，避免内存泄漏
 * 4. 所有任务数据从 MainService 获取，更新通过 MainService 接口
 */
public class PositionAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements MainService.TaskUpdateListener {
    public static final String TAG = "PositionAdapter";

    // 视图类型常量（Java 7 静态常量定义）
    private static final int VIEW_TYPE_SIMPLE = 0;
    private static final int VIEW_TYPE_EDIT = 1;

    // 默认配置常量（统一管理，避免魔法值）
    private static final String DEFAULT_MEMO = "无备注";
    private static final String DEFAULT_TASK_DESC = "新任务";
    private static final int DEFAULT_TASK_DISTANCE = 50; // 单位：米
    private static final String DISTANCE_FORMAT = "实时距离：%.1f 米";
    private static final String DISTANCE_DISABLED = "实时距离：未启用";
    private static final String DISTANCE_ERROR = "实时距离：计算失败";

    // 核心依赖（Java 7 弱引用+集合定义）
    private final Context mContext;
    private final ArrayList<PositionModel> mCachedPositionList; // 位置缓存（从Activity传入，最终需与MainService同步）
    private final WeakReference<MainService> mMainServiceRef;   // 弱引用MainService，避免内存泄漏
    private final ConcurrentHashMap<String, TextView> mPosDistanceViewMap; // 距离控件缓存（优化UI更新）

    // 回调接口（与Activity交互，仅处理位置逻辑，任务逻辑直接调用MainService）
    public interface OnDeleteClickListener {
        void onDeleteClick(int position);
    }

    public interface OnSavePositionClickListener {
        void onSavePositionClick(int position, PositionModel updatedPos);
    }

    private OnDeleteClickListener mOnDeleteListener;
    private OnSavePositionClickListener mOnSavePosListener;

    // =========================================================================
    // 构造函数（Java 7 风格：初始化依赖+注册任务监听）
    // =========================================================================
    public PositionAdapter(Context context, ArrayList<PositionModel> cachedPositionList, MainService mainService) {
        this.mContext = context;
        // 容错处理：避免传入null导致空指针
        this.mCachedPositionList = (cachedPositionList != null) ? cachedPositionList : new ArrayList<PositionModel>();
        // 弱引用MainService：防止Adapter持有Service导致内存泄漏（Java 7 弱引用语法）
        this.mMainServiceRef = new WeakReference<MainService>(mainService);
        // 初始化距离控件缓存（线程安全集合，适配多线程更新场景）
        this.mPosDistanceViewMap = new ConcurrentHashMap<String, TextView>();

        // 注册MainService任务监听：服务任务变化时自动刷新Adapter（Java 7 接口实现）
        if (mainService != null) {
            mainService.registerTaskUpdateListener(this);
            LogUtils.d(TAG, "已注册MainService任务监听，确保任务数据与服务同步");
        } else {
            LogUtils.w(TAG, "构造函数：MainService为空，任务数据无法同步");
        }

        LogUtils.d(TAG, "Adapter初始化完成：位置数量=" + mCachedPositionList.size());
    }

    // =========================================================================
    // RecyclerView 核心方法（Java 7 语法适配）
    // =========================================================================
    @Override
    public int getItemViewType(int position) {
        // 从位置缓存获取状态，判断视图类型（简单/编辑）
        PositionModel posModel = getPositionByIndex(position);
        return (posModel != null && posModel.isSimpleView()) ? VIEW_TYPE_SIMPLE : VIEW_TYPE_EDIT;
    }

    @Override
    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        LayoutInflater inflater = LayoutInflater.from(mContext);
        // 根据视图类型加载对应布局（Java 7 条件判断）
        if (viewType == VIEW_TYPE_SIMPLE) {
            View simpleView = inflater.inflate(R.layout.item_position_simple, parent, false);
            return new SimpleViewHolder(simpleView);
        } else {
            View editView = inflater.inflate(R.layout.item_position_edit, parent, false);
            return new EditViewHolder(editView);
        }
    }

    @Override
    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
        PositionModel posModel = getPositionByIndex(position);
        if (posModel == null) {
            LogUtils.w(TAG, "onBindViewHolder：位置模型为空（索引=" + position + "），跳过绑定");
            return;
        }
        String posId = posModel.getPositionId();

        // 按视图类型绑定数据（Java 7 类型判断）
        if (holder instanceof SimpleViewHolder) {
            bindSimpleView((SimpleViewHolder) holder, posModel);
        } else if (holder instanceof EditViewHolder) {
            bindEditView((EditViewHolder) holder, posModel, position);
        }

        // 缓存当前位置的距离控件（后续局部更新距离时直接使用）
        TextView distanceView = (holder instanceof SimpleViewHolder)
			? ((SimpleViewHolder) holder).tvSimpleDistance
			: ((EditViewHolder) holder).tvEditDistance;
        if (distanceView != null && !TextUtils.isEmpty(posId)) {
            mPosDistanceViewMap.put(posId, distanceView);
        }
    }

    @Override
    public void onViewDetachedFromWindow(RecyclerView.ViewHolder holder) {
        super.onViewDetachedFromWindow(holder);
        // 视图离开屏幕时，移除距离控件缓存（避免内存泄漏+引用失效控件）
        PositionModel posModel = getPositionByIndex(holder.getAdapterPosition());
        if (posModel != null && !TextUtils.isEmpty(posModel.getPositionId())) {
            mPosDistanceViewMap.remove(posModel.getPositionId());
            LogUtils.d(TAG, "视图脱离屏幕：移除位置ID=" + posModel.getPositionId() + "的距离控件缓存");
        }
    }

    @Override
    public int getItemCount() {
        // 直接从位置缓存获取数量（数据源唯一）
        return mCachedPositionList.size();
    }

    // =========================================================================
    // 视图绑定逻辑（Java 7 风格：任务数据从MainService获取）
    // =========================================================================
    /**
     * 绑定简单视图（仅显示数据，点击切换到编辑视图）
     */
    private void bindSimpleView(final SimpleViewHolder holder, final PositionModel posModel) {
        // 1. 显示经纬度（Java 7 String.format格式化）
        holder.tvSimpleLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
        holder.tvSimpleLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));

        // 2. 显示备注（无备注时显示默认文本）
        String memo = posModel.getMemo();
        holder.tvSimpleMemo.setText("备注：" + (TextUtils.isEmpty(memo) ? DEFAULT_MEMO : memo));

        // 3. 显示实时距离（从位置模型取数，调用工具方法更新显示）
        updateDistanceDisplay(holder.tvSimpleDistance, posModel);

        // 4. 点击切换到编辑视图（Java 7 匿名内部类实现点击事件）
        holder.itemView.setOnClickListener(new View.OnClickListener() {
				@Override
				public void onClick(View v) {
					posModel.setIsSimpleView(false); // 修改位置缓存状态
					// 通知RecyclerView刷新当前项（精准更新，避免全量刷新）
					notifyItemChanged(getPositionIndexById(posModel.getPositionId()));
					LogUtils.d(TAG, "简单视图点击：位置ID=" + posModel.getPositionId() + "，切换到编辑视图");
				}
			});
    }

    /**
     * 绑定编辑视图（支持修改备注、开关距离、删除/保存位置、新增任务）
     */
    private void bindEditView(final EditViewHolder holder, final PositionModel posModel, final int position) {
        final String posId = posModel.getPositionId();

        // 1. 显示经纬度（不可编辑，仅展示）
        holder.tvEditLon.setText(String.format("经度：%.6f", posModel.getLongitude()));
        holder.tvEditLat.setText(String.format("纬度：%.6f", posModel.getLatitude()));

        // 2. 显示备注（编辑框赋值，光标定位到末尾）
        String memo = posModel.getMemo();
        if (!TextUtils.isEmpty(memo)) {
            holder.etEditMemo.setText(memo);
            holder.etEditMemo.setSelection(memo.length()); // 光标定位到文本末尾
        } else {
            holder.etEditMemo.setText(""); // 无备注时清空编辑框
        }

        // 3. 显示实时距离（与简单视图逻辑一致）
        updateDistanceDisplay(holder.tvEditDistance, posModel);

        // 4. 设置距离开关状态（匹配位置缓存中的启用状态）
        holder.rgDistanceSwitch.check(posModel.isEnableRealPositionDistance()
									  ? R.id.rb_distance_enable
									  : R.id.rb_distance_disable);

        // 5. 取消编辑：切换回简单视图（Java 7 匿名内部类）
        holder.btnCancel.setOnClickListener(new View.OnClickListener() {
				@Override
				public void onClick(View v) {
					posModel.setIsSimpleView(true);
					notifyItemChanged(position);
					hideSoftKeyboard(v); // 隐藏软键盘（提升用户体验）
					LogUtils.d(TAG, "取消编辑：位置ID=" + posId + "，切换回简单视图");
				}
			});

        // 6. 删除位置：回调Activity处理（Adapter不直接删数据，由Activity同步MainService）
        holder.btnDelete.setOnClickListener(new View.OnClickListener() {
				@Override
				public void onClick(View v) {
					if (mOnDeleteListener != null) {
						mOnDeleteListener.onDeleteClick(position); // 通知Activity删除指定索引
					}
					hideSoftKeyboard(v);
					LogUtils.d(TAG, "触发删除：通知Activity处理位置ID=" + posId + "的删除逻辑");
				}
			});

        // 7. 保存位置：回调Activity保存（收集参数→构建更新模型→通知Activity）
        holder.btnSave.setOnClickListener(new View.OnClickListener() {
				@Override
				public void onClick(View v) {
					// 收集编辑后的参数（备注+距离启用状态）
					String newMemo = holder.etEditMemo.getText().toString().trim();
					boolean isDistanceEnable = (holder.rgDistanceSwitch.getCheckedRadioButtonId() == R.id.rb_distance_enable);

					// 构建更新后的位置模型（保留原核心数据，仅更新可编辑字段）
					PositionModel updatedPos = new PositionModel();
					updatedPos.setPositionId(posId); // 保留原ID（不可修改）
					updatedPos.setLongitude(posModel.getLongitude()); // 保留原经度（不可编辑）
					updatedPos.setLatitude(posModel.getLatitude());   // 保留原纬度（不可编辑）
					updatedPos.setMemo(newMemo);                      // 更新备注（用户编辑）
					updatedPos.setIsEnableRealPositionDistance(isDistanceEnable); // 更新距离状态
					updatedPos.setIsSimpleView(true);                 // 切换回简单视图

					// 回调Activity保存（由Activity同步MainService+位置缓存，Adapter不处理逻辑）
					if (mOnSavePosListener != null) {
						mOnSavePosListener.onSavePositionClick(position, updatedPos);
					}

					// 本地同步状态（避免刷新延迟，直接修改位置缓存）
					posModel.setMemo(newMemo);
					posModel.setIsEnableRealPositionDistance(isDistanceEnable);
					posModel.setIsSimpleView(true);
					notifyItemChanged(position); // 刷新当前项，显示更新后的状态
					hideSoftKeyboard(v);
					LogUtils.d(TAG, "触发保存：位置ID=" + posId + "，新备注=" + newMemo + "，距离启用=" + isDistanceEnable);
				}
			});

        // 8. 绑定任务视图（显示任务数量+新增任务，数据从MainService获取）
        bindTaskView(holder, posId);
    }

    /**
     * 绑定任务视图（编辑模式专属：从MainService获取任务数据，新增任务调用服务接口）
     */
    private void bindTaskView(final EditViewHolder holder, final String posId) {
        // 1. 从MainService获取当前位置的任务数量（Java 7 迭代器遍历服务数据）
        int taskCount = 0;
        MainService mainService = mMainServiceRef.get();
        if (mainService != null) {
            ArrayList<PositionTaskModel> posTasks = mainService.getTasksByPositionId(posId);
            taskCount = (posTasks != null) ? posTasks.size() : 0;
        }
        // 显示任务数量（简化设计，实际可扩展为任务列表）
        holder.tvTaskCount.setText("任务数量：" + taskCount);

        // 2. 新增任务：调用MainService接口（不操作本地缓存，数据直接写入服务）
        holder.btnAddTask.setOnClickListener(new View.OnClickListener() {
				@Override
				public void onClick(View v) {
					MainService mainService = mMainServiceRef.get();
					if (mainService == null) {
						LogUtils.e(TAG, "新增任务失败：MainService已回收（弱引用失效）");
						return;
					}

					// 构建默认任务模型（Java 7 显式初始化）
					PositionTaskModel newTask = new PositionTaskModel();
					newTask.setTaskId(PositionTaskModel.genTaskId()); // 生成唯一任务ID（需在PositionTaskModel实现静态方法）
					newTask.setPositionId(posId);                     // 绑定当前位置ID
					newTask.setTaskDescription(DEFAULT_TASK_DESC);    // 默认任务描述
					newTask.setIsEnable(true);                        // 默认启用任务
					newTask.setDiscussDistance(DEFAULT_TASK_DISTANCE);// 默认任务距离（50米）

					// 调用MainService接口新增任务（数据写入服务，由服务处理持久化+通知刷新）
					mainService.addPositionTask(newTask);
					hideSoftKeyboard(v);
					LogUtils.d(TAG, "触发新增任务：调用MainService接口，位置ID=" + posId + "，任务ID=" + newTask.getTaskId());
				}
			});
    }

    // =========================================================================
    // 工具方法（Java 7 风格：无Lambda，纯匿名内部类+迭代器）
    // =========================================================================
    /**
     * 更新距离显示（根据位置模型状态，显示不同文本+颜色）
     */
    private void updateDistanceDisplay(TextView distanceView, PositionModel posModel) {
        if (distanceView == null || posModel == null) {
            LogUtils.w(TAG, "updateDistanceDisplay：参数为空（控件/位置模型）");
            return;
        }

        // 场景1：距离未启用
        if (!posModel.isEnableRealPositionDistance()) {
            distanceView.setText(DISTANCE_DISABLED);
            distanceView.setTextColor(mContext.getResources().getColor(R.color.gray));
            return;
        }

        // 场景2：距离计算失败（用-1标记失败状态）
        double distance = posModel.getRealPositionDistance();
        if (distance < 0) {
            distanceView.setText(DISTANCE_ERROR);
            distanceView.setTextColor(mContext.getResources().getColor(R.color.red));
            return;
        }

        // 场景3：正常显示距离（按距离范围设置颜色，提升视觉区分度）
        distanceView.setText(String.format(DISTANCE_FORMAT, distance));
        if (distance <= 100) {
            distanceView.setTextColor(mContext.getResources().getColor(R.color.green)); // 近距离（≤100米）
        } else if (distance <= 500) {
            distanceView.setTextColor(mContext.getResources().getColor(R.color.yellow));// 中距离（≤500米）
        } else {
            distanceView.setTextColor(mContext.getResources().getColor(R.color.red));   // 远距离（>500米）
        }
    }

    /**
     * 根据索引获取位置模型（从位置缓存取数，容错处理）
     */
    private PositionModel getPositionByIndex(int index) {
        if (mCachedPositionList == null || index < 0 || index >= mCachedPositionList.size()) {
            LogUtils.w(TAG, "getPositionByIndex：无效索引（" + index + "）或位置缓存为空");
            return null;
        }
        return mCachedPositionList.get(index);
    }

    /**
     * 根据位置ID获取列表索引（用于精准刷新视图）
     */
    private int getPositionIndexById(String positionId) {
        if (TextUtils.isEmpty(positionId) || mCachedPositionList == null || mCachedPositionList.isEmpty()) {
            LogUtils.w(TAG, "getPositionIndexById：参数无效（位置ID/缓存为空）");
            return -1;
        }

        // Java 7 增强for循环遍历（替代Lambda，适配Java 7语法）
        for (int i = 0; i < mCachedPositionList.size(); i++) {
            PositionModel pos = mCachedPositionList.get(i);
            if (positionId.equals(pos.getPositionId())) {
                return i; // 找到匹配ID，返回索引
            }
        }
        LogUtils.w(TAG, "getPositionIndexById：未找到位置ID=" + positionId);
        return -1;
    }

    /**
     * 局部更新距离UI（仅更新指定位置的距离，避免全量刷新卡顿）
     */
    public void updateSinglePositionDistance(String positionId) {
        // 校验参数：位置ID无效或控件未缓存，直接返回
        if (TextUtils.isEmpty(positionId) || !mPosDistanceViewMap.containsKey(positionId)) {
            LogUtils.w(TAG, "updateSinglePositionDistance：位置ID无效或控件未缓存（ID=" + positionId + "）");
            return;
        }

        // 从MainService获取最新位置模型（确保距离值是服务端最新）
        PositionModel latestPos = null;
        MainService mainService = mMainServiceRef.get();
        if (mainService != null) {
            ArrayList<PositionModel> servicePosList = mainService.getPositionList();
            if (servicePosList != null && !servicePosList.isEmpty()) {
                // Java 7 迭代器遍历服务端位置列表，找到目标位置
                Iterator<PositionModel> posIter = servicePosList.iterator();
                while (posIter.hasNext()) {
                    PositionModel pos = posIter.next();
                    if (positionId.equals(pos.getPositionId())) {
                        latestPos = pos;
                        break;
                    }
                }
            }
        }

        // 用服务端最新距离更新UI（直接操作缓存的距离控件，无需刷新整个项）
        if (latestPos != null) {
            TextView distanceView = mPosDistanceViewMap.get(positionId);
            updateDistanceDisplay(distanceView, latestPos);
            LogUtils.d(TAG, "局部更新距离完成：位置ID=" + positionId + "，最新距离=" + latestPos.getRealPositionDistance() + "米");
        } else {
            LogUtils.w(TAG, "局部更新距离失败：未在MainService找到位置ID=" + positionId);
        }
    }

    /**
     * 全量更新位置数据（从MainService同步最新位置列表，刷新UI）
     */
    public void updateAllPositionData(ArrayList<PositionModel> newPosList) {
        if (newPosList == null) {
            LogUtils.w(TAG, "updateAllPositionData：新位置列表为空，跳过更新");
            return;
        }

        // 同步服务端最新位置数据到本地缓存
        this.mCachedPositionList.clear();
        this.mCachedPositionList.addAll(newPosList);
        // 清空旧距离控件缓存（避免引用失效控件）
        mPosDistanceViewMap.clear();
        // 通知RecyclerView全量刷新UI
        notifyDataSetChanged();
        LogUtils.d(TAG, "全量更新位置数据完成：当前位置数量=" + mCachedPositionList.size() + "（数据来源：MainService）");
    }

    /**
     * 隐藏软键盘（编辑完成后调用，提升用户体验）
     */
    private void hideSoftKeyboard(View view) {
        if (mContext == null || view == null) {
            LogUtils.w(TAG, "hideSoftKeyboard：参数为空（上下文/视图），无法隐藏键盘");
            return;
        }

        // Java 7 显式获取输入法服务，避免Lambda
        InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
        if (imm != null) {
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0); // 强制隐藏软键盘
        }
    }

    // =========================================================================
    // 实现 MainService.TaskUpdateListener 接口（服务任务变化时回调）
    // =========================================================================
    @Override
    public void onTaskUpdated() {
        LogUtils.d(TAG, "收到MainService任务更新通知（任务新增/删除/状态变化），刷新UI");
        // 任务数据变化时，全量刷新Adapter（确保任务数量等显示同步）
        notifyDataSetChanged();
    }

    // =========================================================================
    // 回调设置方法（供LocationActivity调用，绑定交互逻辑）
    // =========================================================================
    public void setOnDeleteClickListener(OnDeleteClickListener listener) {
        this.mOnDeleteListener = listener;
    }

    public void setOnSavePositionClickListener(OnSavePositionClickListener listener) {
        this.mOnSavePosListener = listener;
    }

    // =========================================================================
    // 资源释放（Activity销毁时调用，避免内存泄漏）
    // =========================================================================
    public void release() {
        // 1. 反注册MainService任务监听（解除与服务的绑定，避免内存泄漏）
        MainService mainService = mMainServiceRef.get();
        if (mainService != null) {
            mainService.unregisterTaskUpdateListener(this);
            LogUtils.d(TAG, "已反注册MainService任务监听，避免内存泄漏");
        }

        // 2. 清空本地缓存（解除控件/数据引用，帮助GC回收）
        mPosDistanceViewMap.clear();
        if (mCachedPositionList != null) {
            mCachedPositionList.clear();
        }

        // 3. 置空回调实例（避免持有Activity引用导致内存泄漏）
        mOnDeleteListener = null;
        mOnSavePosListener = null;

        LogUtils.d(TAG, "Adapter资源已完全释放（缓存清空+监听反注册）");
    }

    // =========================================================================
    // 静态内部类：视图Holder（Java 7 静态内部类，不持有外部引用，避免内存泄漏）
    // =========================================================================
    /**
     * 简单视图Holder（仅显示数据，对应布局：item_position_simple.xml）
     */
    public static class SimpleViewHolder extends RecyclerView.ViewHolder {
        TextView tvSimpleLon;     // 经度显示控件
        TextView tvSimpleLat;     // 纬度显示控件
        TextView tvSimpleMemo;    // 备注显示控件
        TextView tvSimpleDistance;// 实时距离显示控件

        public SimpleViewHolder(View itemView) {
            super(itemView);
            // 绑定布局控件（与XML中ID严格对应，避免运行时空指针）
            tvSimpleLon = (TextView) itemView.findViewById(R.id.tv_simple_longitude);
            tvSimpleLat = (TextView) itemView.findViewById(R.id.tv_simple_latitude);
            tvSimpleMemo = (TextView) itemView.findViewById(R.id.tv_simple_memo);
            tvSimpleDistance = (TextView) itemView.findViewById(R.id.tv_simple_distance);
        }
    }

    /**
     * 编辑视图Holder（含编辑控件+功能按钮，对应布局：item_position_edit.xml）
     */
    public static class EditViewHolder extends RecyclerView.ViewHolder {
        TextView tvEditLon;       // 经度显示控件（不可编辑）
        TextView tvEditLat;       // 纬度显示控件（不可编辑）
        EditText etEditMemo;      // 备注编辑控件
        TextView tvEditDistance;  // 实时距离显示控件
        RadioGroup rgDistanceSwitch; // 距离启用/禁用开关组
        Button btnCancel;         // 取消编辑按钮
        Button btnDelete;         // 删除位置按钮
        Button btnSave;           // 保存位置按钮
        Button btnAddTask;        // 新增任务按钮
        TextView tvTaskCount;     // 任务数量显示控件

        public EditViewHolder(View itemView) {
            super(itemView);
            // 绑定布局控件（与XML中ID严格对应，避免运行时空指针）
            tvEditLon = (TextView) itemView.findViewById(R.id.tv_edit_longitude);
            tvEditLat = (TextView) itemView.findViewById(R.id.tv_edit_latitude);
            etEditMemo = (EditText) itemView.findViewById(R.id.et_edit_memo);
            tvEditDistance = (TextView) itemView.findViewById(R.id.tv_edit_distance);
            rgDistanceSwitch = (RadioGroup) itemView.findViewById(R.id.rg_distance_switch);
            btnCancel = (Button) itemView.findViewById(R.id.btn_edit_cancel);
            btnDelete = (Button) itemView.findViewById(R.id.btn_edit_delete);
            btnSave = (Button) itemView.findViewById(R.id.btn_edit_save);
            btnAddTask = (Button) itemView.findViewById(R.id.btn_add_task);
            tvTaskCount = (TextView) itemView.findViewById(R.id.tv_task_count);
        }
    }
}

