package net.micode.notes.data;

import android.app.SearchManager;
import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Intent;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.text.TextUtils;
import android.util.Log;

import net.micode.notes.R;
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;

// NotesProvider类继承自ContentProvider，是Android中用于在不同应用组件间共享数据的抽象基类
// 本类主要负责处理与笔记相关的数据操作，如查询、插入、删除、更新等，并与底层数据库进行交互
public class NotesProvider extends ContentProvider {

    // UriMatcher用于根据传入的Uri来匹配相应的操作码，以确定要执行何种数据操作
    // 这里定义为静态成员变量，方便在类的不同方法中使用相同的匹配规则来判断Uri类型
    private static final UriMatcher mMatcher;

    // NotesDatabaseHelper的实例，用于辅助进行数据库相关操作，例如获取数据库连接、执行SQL语句等
    private NotesDatabaseHelper mHelper;

    // 用于日志记录的标签，方便在查看日志时快速识别是该类中输出的日志信息
    private static final String TAG = "NotesProvider";

    // 以下定义了不同的整数常量，作为不同类型Uri的匹配码，用于区分不同的请求路径对应的操作
    private static final int URI_NOTE = 1;
    private static final int URI_NOTE_ITEM = 2;
    private static final int URI_DATA = 3;
    private static final int URI_DATA_ITEM = 4;
    private static final int URI_SEARCH = 5;
    private static final int URI_SEARCH_SUGGEST = 6;

    // 静态初始化块，用于初始化UriMatcher，添加各种不同格式的Uri匹配规则
    // 通过这些规则，后续可以根据传入的Uri快速判断其对应的操作类型
    static {
        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        // 添加匹配规则，当Uri的权限（Authority）为Notes.AUTHORITY，路径为"note"时，匹配码为URI_NOTE
        // 通常用于对所有笔记进行批量操作的请求
        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
        // 当Uri的权限为Notes.AUTHORITY，路径为"note/数字"（#表示数字占位符）时，匹配码为URI_NOTE_ITEM
        // 一般用于对单个笔记进行操作的请求，数字部分对应具体笔记的ID
        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
        // 为搜索建议相关的Uri添加匹配规则，用于处理搜索建议的请求路径
        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
    }

    // 定义用于搜索结果投影（Projection）的字符串，指定了从数据库查询搜索结果时要返回的列及格式
    // 这里涉及到将笔记的一些字段进行处理后返回，例如去除换行符、设置图标、指定意图相关信息等
    // 以便符合搜索结果展示和后续操作的要求
    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
            + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
            + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
            + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
            + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;

    // 定义用于查询笔记片段搜索的SQL语句模板，基于上面的投影字符串构建
    // 根据笔记片段（SNIPPET）字段进行模糊匹配查询，同时添加了一些筛选条件，如排除回收站文件夹、只查询笔记类型等
    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
            + " FROM " + TABLE.NOTE
            + " WHERE " + NoteColumns.SNIPPET + " LIKE?"
            + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
            + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;

    // 重写ContentProvider的onCreate方法，在内容提供器创建时调用
    // 主要用于初始化NotesDatabaseHelper实例，获取数据库操作的辅助对象，若初始化成功则返回true表示创建成功
    @Override
    public boolean onCreate() {
        mHelper = NotesDatabaseHelper.getInstance(getContext());
        return true;
    }

    // 重写ContentProvider的query方法，用于处理数据查询请求
    // 根据传入的Uri、投影、选择条件等参数，从数据库中查询相应的数据并返回结果集（Cursor）
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
                        String sortOrder) {
        Cursor c = null;
        // 获取可读数据库实例，用于执行查询操作，确保不会对数据库进行写操作
        SQLiteDatabase db = mHelper.getReadableDatabase();
        String id = null;
        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的查询逻辑
        switch (mMatcher.match(uri)) {
            case URI_NOTE:
                // 如果是URI_NOTE类型的Uri，直接对笔记表（TABLE.NOTE）进行查询，使用传入的投影、选择条件等参数
                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
            case URI_NOTE_ITEM:
                // 如果是URI_NOTE_ITEM类型的Uri，先获取路径中的笔记ID（即uri.getPathSegments().get(1)）
                // 然后在查询笔记表时添加基于笔记ID的筛选条件，确保查询的是指定ID的单个笔记
                id = uri.getPathSegments().get(1);
                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
                break;
            case URI_DATA:
                // 针对URI_DATA类型的Uri，对数据表（TABLE.DATA）进行查询，同样使用传入的相关参数
                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
                        sortOrder);
                break;
            case URI_DATA_ITEM:
                // 对于URI_DATA_ITEM类型的Uri，获取路径中的数据ID，然后在查询数据表时添加基于该数据ID的筛选条件
                id = uri.getPathSegments().get(1);
                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
                break;
            case URI_SEARCH:
            case URI_SEARCH_SUGGEST:
                // 如果是搜索或搜索建议相关的Uri类型
                if (sortOrder!= null || projection!= null) {
                    // 若传入了排序顺序或投影参数，则抛出异常，因为对于这种类型的查询不应该指定这些参数
                    throw new IllegalArgumentException(
                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
                }

                String searchString = null;
                // 根据具体是搜索还是搜索建议的Uri类型，获取不同方式传入的搜索字符串
                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
                    if (uri.getPathSegments().size() > 1) {
                        searchString = uri.getPathSegments().get(1);
                    }
                } else {
                    searchString = uri.getQueryParameter("pattern");
                }

                if (TextUtils.isEmpty(searchString)) {
                    // 如果搜索字符串为空，则直接返回null，因为没有内容可查询
                    return null;
                }

                try {
                    // 对搜索字符串进行格式化，添加模糊匹配的通配符（%），用于构建模糊查询条件
                    searchString = String.format("%%%s%%", searchString);
                    // 使用格式化后的搜索字符串，执行原始的SQL查询语句（NOTES_SNIPPET_SEARCH_QUERY）来获取搜索结果
                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
                            new String[] { searchString });
                } catch (IllegalStateException ex) {
                    // 如果在查询过程中出现异常，记录错误日志
                    Log.e(TAG, "got exception: " + ex.toString());
                }
                break;
            default:
                // 如果传入的Uri无法匹配任何已知的类型，则抛出异常，表示未知的Uri请求
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        if (c!= null) {
            // 如果查询到了有效的结果集（Cursor），设置通知Uri，以便在数据变化时通知相关观察者
            c.setNotificationUri(getContext().getContentResolver(), uri);
        }
        return c;
    }

    // 重写ContentProvider的insert方法，用于处理数据插入请求
    // 根据传入的Uri和要插入的数据（ContentValues），将数据插入到相应的数据库表中，并返回插入后数据的Uri
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        long dataId = 0, noteId = 0, insertedId = 0;
        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的插入逻辑
        switch (mMatcher.match(uri)) {
            case URI_NOTE:
                // 如果是URI_NOTE类型的Uri，直接向笔记表（TABLE.NOTE）插入数据，获取插入后笔记的ID
                insertedId = noteId = db.insert(TABLE.NOTE, null, values);
                break;
            case URI_DATA:
                // 对于URI_DATA类型的Uri，先检查要插入的数据中是否包含笔记ID（DataColumns.NOTE_ID）
                if (values.containsKey(DataColumns.NOTE_ID)) {
                    noteId = values.getAsLong(DataColumns.NOTE_ID);
                } else {
                    // 如果没有笔记ID，则记录警告日志，表示数据格式错误
                    Log.d(TAG, "Wrong data format without note id:" + values.toString());
                }
                // 向数据表（TABLE.DATA）插入数据，获取插入后数据的ID
                insertedId = dataId = db.insert(TABLE.DATA, null, values);
                break;
            default:
                // 如果传入的Uri无法匹配任何已知的类型，则抛出异常，表示未知的Uri请求
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        // 如果插入的笔记ID大于0，即成功插入了笔记数据，通知与笔记相关的Uri发生了变化
        // 以便相关观察者（如使用ContentObserver监听的组件）可以做出响应
        if (noteId > 0) {
            getContext().getContentResolver().notifyChange(
                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
        }

        // 如果插入的数据ID大于0，即成功插入了数据，通知与数据相关的Uri发生了变化
        if (dataId > 0) {
            getContext().getContentResolver().notifyChange(
                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
        }

        // 返回插入数据后对应的Uri，通过在原始Uri基础上添加插入数据的ID构建
        return ContentUris.withAppendedId(uri, insertedId);
    }

    // 重写ContentProvider的delete方法，用于处理数据删除请求
    // 根据传入的Uri、选择条件等参数，从相应的数据库表中删除匹配的数据，并返回删除的行数
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int count = 0;
        String id = null;
        SQLiteDatabase db = mHelper.getWritableDatabase();
        boolean deleteData = false;
        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的删除逻辑
        switch (mMatcher.match(uri)) {
            case URI_NOTE:
                // 如果是URI_NOTE类型的Uri，在原选择条件基础上添加笔记ID大于0的条件（确保删除合法的笔记记录）
                // 然后从笔记表（TABLE.NOTE）中删除匹配的数据，获取删除的行数
                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
                count = db.delete(TABLE.NOTE, selection, selectionArgs);
                break;
            case URI_NOTE_ITEM:
                // 如果是URI_NOTE_ITEM类型的Uri，获取路径中的笔记ID
                id = uri.getPathSegments().get(1);
                /**
                 * ID小于等于0的是系统文件夹，不允许删除（移动到回收站），这里进行判断跳过此类操作
                 */
                long noteId = Long.valueOf(id);
                if (noteId <= 0) {
                    break;
                }
                // 根据笔记ID从笔记表中删除相应的记录，获取删除的行数
                count = db.delete(TABLE.NOTE,
                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
                break;
            case URI_DATA:
                // 针对URI_DATA类型的Uri，从数据表（TABLE.DATA）中删除匹配的数据，获取删除的行数，并标记正在删除数据
                count = db.delete(TABLE.DATA, selection, selectionArgs);
                deleteData = true;
                break;
            case URI_DATA_ITEM:
                // 对于URI_DATA_ITEM类型的Uri，获取路径中的数据ID，然后从数据表中删除相应的数据记录，获取删除的行数，并标记正在删除数据
                id = uri.getPathSegments().get(1);
                count = db.delete(TABLE.DATA,
                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
                deleteData = true;
                break;
            default:
                // 如果传入的Uri无法匹配任何已知的类型，则抛出异常，表示未知的Uri请求
                throw new IllegalArgumentException("Unknown URI " + uri);
        }
        if (count > 0) {
            // 如果成功删除了数据（删除行数大于0）
            if (deleteData) {
                // 如果正在删除数据，通知与笔记相关的Uri发生了变化，因为数据的变化可能影响到笔记相关的展示等情况
                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
            }
            // 通知与当前操作的Uri发生了变化，以便相关观察者做出响应
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return count;
    }

    // 重写ContentProvider的update方法，用于处理数据更新请求
    // 根据传入的Uri、要更新的数据（ContentValues）、选择条件等参数，更新相应数据库表中的数据，并返回更新的行数
    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        int count = 0;
        String id = null;
        SQLiteDatabase db = mHelper.getWritableDatabase();
        boolean updateData = false;
        // 使用UriMatcher匹配传入的Uri，根据匹配结果执行不同的更新逻辑
        switch (mMatcher.match(uri)) {
            case URI_NOTE:
                // 如果是URI_NOTE类型的Uri，先调用increaseNoteVersion方法来更新笔记的版本号（可能用于版本控制等逻辑）
                increaseNoteVersion(-1, selection, selectionArgs);
                // 然后根据传入的参数更新笔记表（TABLE.NOTE）中的数据，获取更新的行数
                count = db.update(TABLE.NOTE, values, selection, selectionArgs);
                break;
            case URI_NOTE_ITEM:
                // 如果是URI_NOTE_ITEM类型的Uri，获取路径中的笔记ID
                id = uri.getPathSegments().get(1);
                // 调用increaseNoteVersion方法根据笔记ID来更新笔记的版本号
                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
                // 根据笔记ID和其他传入参数更新笔记表中的相应记录，获取更新的行数
                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
                        + parseSelection(selection), selectionArgs);
                break;
            case URI_DATA:
                // 针对URI_DATA类型的Uri，直接根据传入参数更新数据表（TABLE.DATA）中的数据，获取更新的行数，并标记正在更新数据
                count = db.update(TABLE.DATA, values, selection, selectionArgs);
                updateData = true;
                break;
            case URI_DATA_ITEM:
                // 对于