/*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.micode.notes.ui;

import android.content.Context;
import android.graphics.Color;
import android.graphics.Paint;
import android.text.Editable;
import android.text.TextWatcher;
import android.text.format.DateUtils;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;

import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.DataUtils;
import net.micode.notes.tool.ResourceParser.NoteItemBgResources;

/**
 * 笔记列表项视图
 * 用于在列表中显示单个笔记项
 */
/**
 * 笔记列表项视图
 * 用于在笔记列表中显示单个笔记项的自定义视图
 */
public class NotesListItem extends LinearLayout {
    /** 提醒图标 */
    private ImageView mAlert;
    /** 加密图标 */
    private ImageView mEncryptedIcon;
    /** 笔记标题文本视图 */
    private TextView mTitle;
    /** 时间文本视图 */
    private TextView mTime;
    /** 联系人姓名文本视图（用于通话记录） */
    private TextView mCallName;
    /** 笔记项数据 */
    private NoteItemData mItemData;
    /** 复选框（用于选择模式） */
    private CheckBox mCheckBox;
    /** 清单标题编辑框 */
    private EditText mChecklistTitle;
    /** 清单状态图标 */
    private ImageView mChecklistStatus;
    /** 上下文 */
    private Context mContext;
    /** 当前是否为清单模式 */
    private boolean mIsChecklistMode;
    /** 标题监听器，用于保存清单标题变更 */
    private OnTitleChangedListener mOnTitleChangedListener;
    /** 完成状态监听器，用于保存清单项目完成状态变更 */
    private OnCheckStatusChangedListener mOnCheckStatusChangedListener;

    /**
     * 标题变更监听器接口
     */
    public interface OnTitleChangedListener {
        void onTitleChanged(long noteId, String newTitle);
    }

    /**
     * 完成状态变更监听器接口
     */
    public interface OnCheckStatusChangedListener {
        void onCheckStatusChanged(long noteId, boolean isChecked);
    }

    /**
     * 设置标题变更监听器
     * @param listener 监听器
     */
    public void setOnTitleChangedListener(OnTitleChangedListener listener) {
        mOnTitleChangedListener = listener;
    }

    /**
     * 设置完成状态变更监听器
     * @param listener 监听器
     */
    public void setOnCheckStatusChangedListener(OnCheckStatusChangedListener listener) {
        mOnCheckStatusChangedListener = listener;
    }

    /**
     * 创建一个笔记列表项视图实例
     * @param context 上下文
     */
    public NotesListItem(Context context) {
        super(context);
        mContext = context;
        // 填充布局
        inflate(context, R.layout.note_item, this);
        // 获取视图组件
        mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
        mEncryptedIcon = (ImageView) findViewById(R.id.iv_encrypted_icon);
        mTitle = (TextView) findViewById(R.id.tv_title);
        mTime = (TextView) findViewById(R.id.tv_time);
        mCallName = (TextView) findViewById(R.id.tv_name);
        mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
        // 初始化清单相关组件
        mChecklistTitle = (EditText) findViewById(R.id.et_checklist_title);
        mChecklistStatus = (ImageView) findViewById(R.id.iv_checklist_status);

        // 设置清单标题编辑框的文本变更监听器
        mChecklistTitle.addTextChangedListener(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) {
                // 文本变更时的处理
            }

            @Override
            public void afterTextChanged(Editable s) {
                // 文本变更后的处理，保存新标题
                if (mItemData != null && mOnTitleChangedListener != null) {
                    mOnTitleChangedListener.onTitleChanged(mItemData.getId(), s.toString());
                }
            }
        });
    }

    /**
     * 将笔记数据绑定到视图
     * @param context 上下文
     * @param data 笔记项数据
     * @param choiceMode 是否为选择模式
     * @param checked 是否被选中
     */
    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
        bind(context, data, choiceMode, checked, false);
    }

    /**
     * 将笔记数据绑定到视图
     * @param context 上下文
     * @param data 笔记项数据
     * @param choiceMode 是否为选择模式
     * @param checked 是否被选中
     * @param isChecklistMode 是否为清单模式
     */
    public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked, boolean isChecklistMode) {
        mContext = context;
        mIsChecklistMode = isChecklistMode;

        // 先默认隐藏复选框
        mCheckBox.setVisibility(View.GONE);

        mItemData = data;

        // 重置视图状态
        mTitle.setVisibility(View.VISIBLE);
        mChecklistTitle.setVisibility(View.GONE);
        mChecklistStatus.setVisibility(View.GONE);

        // 处理通话记录文件夹
        if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
            mCallName.setVisibility(View.GONE);
            mAlert.setVisibility(View.VISIBLE);
            mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
            mTitle.setText(context.getString(R.string.call_record_folder_name)
                    + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
            mAlert.setImageResource(R.drawable.call_record);
        }
        // 处理通话记录笔记
        else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
            mCallName.setVisibility(View.VISIBLE);
            mCallName.setText(data.getCallName());
            mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
            mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
            if (data.hasAlert()) {
                mAlert.setImageResource(R.drawable.clock);
                mAlert.setVisibility(View.VISIBLE);
            } else {
                mAlert.setVisibility(View.GONE);
            }
        }
        // 处理普通文件夹或笔记
        else {
            mCallName.setVisibility(View.GONE);

            if (data.getType() == Notes.TYPE_FOLDER) {
                // 文件夹显示格式：名称 + 数量
                mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
                mTitle.setText(data.getSnippet()
                        + context.getString(R.string.format_folder_files_count,
                        data.getNotesCount()));
                mAlert.setVisibility(View.GONE);
            } else {
                // 处理清单模式
                if (isChecklistMode) {
                    // 清单模式：显示编辑框和复选框，隐藏TextView和状态指示器
                    mTitle.setVisibility(View.GONE);
                    mChecklistTitle.setVisibility(View.VISIBLE);
                    mCheckBox.setVisibility(View.VISIBLE);
                    mChecklistStatus.setVisibility(View.GONE);

                    // 设置清单标题
                    String title = data.getSnippet();
                    mChecklistTitle.setText(title);
                    mChecklistTitle.setSelection(title.length());

                    // 初始状态下，EditText不可编辑，只能长按后编辑
                    mChecklistTitle.setFocusable(false);
                    mChecklistTitle.setFocusableInTouchMode(false);
                    mChecklistTitle.setClickable(false);
                    mChecklistTitle.setCursorVisible(false);

                    // 根据完成状态设置复选框和样式
                    boolean isChecked = data.isChecked();
                    mCheckBox.setChecked(isChecked);
                    updateChecklistStyle(isChecked);

                    // 添加复选框点击事件，切换完成状态
                    mCheckBox.setClickable(true);
                    mCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
                        @Override
                        public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                            // 切换完成状态
                            data.setChecked(isChecked);

                            // 更新UI
                            updateChecklistStyle(isChecked);

                            // 通知监听器，保存完成状态到数据库
                            if (mOnCheckStatusChangedListener != null) {
                                mOnCheckStatusChangedListener.onCheckStatusChanged(data.getId(), isChecked);
                            }
                        }
                    });

                    // 添加长按事件，长按后可编辑
                    mChecklistTitle.setLongClickable(true);
                    mChecklistTitle.setOnLongClickListener(new OnLongClickListener() {
                        @Override
                        public boolean onLongClick(View v) {
                            // 设置为可编辑状态
                            mChecklistTitle.setFocusable(true);
                            mChecklistTitle.setFocusableInTouchMode(true);
                            mChecklistTitle.setClickable(true);
                            mChecklistTitle.setCursorVisible(true);

                            // 获得焦点并弹出键盘
                            mChecklistTitle.requestFocus();
                            mChecklistTitle.setSelection(mChecklistTitle.getText().length());

                            // 强制弹出键盘
                            InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
                            if (imm != null) {
                                imm.showSoftInput(mChecklistTitle, InputMethodManager.SHOW_FORCED);
                            }

                            return true; // 消耗长按事件，避免触发其他长按事件
                        }
                    });

                    // 添加焦点变化监听器，失去焦点时保存修改并恢复为不可编辑状态
                    mChecklistTitle.setOnFocusChangeListener(new OnFocusChangeListener() {
                        @Override
                        public void onFocusChange(View v, boolean hasFocus) {
                            if (!hasFocus) {
                                // 失去焦点时，保存修改并恢复为不可编辑状态
                                mChecklistTitle.setFocusable(false);
                                mChecklistTitle.setFocusableInTouchMode(false);
                                mChecklistTitle.setClickable(false);
                                mChecklistTitle.setCursorVisible(false);
                            }
                        }
                    });
                } else {
                    // 普通模式：显示TextView，隐藏编辑框
                    mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
                    mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));

                    if (data.hasAlert()) {
                        mAlert.setImageResource(R.drawable.clock);
                        mAlert.setVisibility(View.VISIBLE);
                    } else {
                        mAlert.setVisibility(View.GONE);
                    }
                }
            }
        }

        // 设置修改时间
        mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));

        // 显示加密图标
        if (data.isEncrypted()) {
            mEncryptedIcon.setVisibility(View.VISIBLE);
            mEncryptedIcon.setImageResource(android.R.drawable.ic_lock_lock);
        } else {
            mEncryptedIcon.setVisibility(View.GONE);
        }

        // 设置背景
        setBackground(data);
    }

    /**
     * 更新清单状态图标
     */
    private void updateChecklistStatus() {
        if (mChecklistStatus == null || mItemData == null) {
            return;
        }

        // TODO: 根据清单完成情况更新状态图标
        // 这里可以实现逻辑，检查清单中已完成项的比例，显示不同的状态图标
        mChecklistStatus.setImageResource(R.drawable.clock);
    }

    /**
     * 更新清单项目样式
     * @param isChecked 是否已完成
     */
    private void updateChecklistStyle(boolean isChecked) {
        if (isChecked) {
            // 已完成：显示删除线，文字变暗
            mChecklistTitle.setPaintFlags(mChecklistTitle.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
            mChecklistTitle.setTextColor(Color.GRAY);
        } else {
            // 未完成：正常显示
            mChecklistTitle.setPaintFlags(mChecklistTitle.getPaintFlags() & (~Paint.STRIKE_THRU_TEXT_FLAG));
            mChecklistTitle.setTextColor(Color.BLACK);
        }
    }

    /**
     * 设置笔记项的背景
     * @param data 笔记项数据
     */
    private void setBackground(NoteItemData data) {
        int id = data.getBgColorId();

        if (data.getType() == Notes.TYPE_NOTE || data.getType() == Notes.TYPE_CHECKLIST) {
            // 根据笔记或清单在列表中的位置选择不同的背景
            if (data.isSingle() || data.isOneFollowingFolder()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
            } else if (data.isLast()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
            } else if (data.isFirst() || data.isMultiFollowingFolder()) {
                setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
            } else {
                setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
            }
        } else {
            // 文件夹使用固定背景
            setBackgroundResource(NoteItemBgResources.getFolderBgRes());
        }
    }

    /**
     * 获取笔记项数据
     * @return 笔记项数据
     */
    public NoteItemData getItemData() {
        return mItemData;
    }
}
