/*
 * 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.model;

 

// 导入所需的Android和Java类

import android.content.ContentProviderOperation;

import android.content.ContentProviderResult;

import android.content.ContentUris;

import android.content.ContentValues;

import android.content.Context;

import android.content.OperationApplicationException;

import android.net.Uri;

import android.os.RemoteException;

import android.util.Log;

 

import net.micode.notes.data.Notes;

import net.micode.notes.data.Notes.CallNote;

import net.micode.notes.data.Notes.DataColumns;

import net.micode.notes.data.Notes.NoteColumns;

import net.micode.notes.data.Notes.TextNote;

 

import java.util.ArrayList;

 

// Note类，用于表示和管理笔记数据

public class Note {

    // 用于存储笔记的差异值（即需要更新的字段）

    private ContentValues mNoteDiffValues;

    // 用于存储笔记的具体数据（如文本数据、通话数据等）

    private NoteData mNoteData;

    // 日志标签

    private static final String TAG = "Note";

 

    /**

     * 创建一个新的笔记ID，用于将新笔记添加到数据库中

     */

    public static synchronized long getNewNoteId(Context context, long folderId) {

        // 创建一个新的ContentValues对象，用于存储要插入数据库的数据

        ContentValues values = new ContentValues();

        // 获取当前时间，作为笔记的创建和修改时间

        long createdTime = System.currentTimeMillis();

        values.put(NoteColumns.CREATED_DATE, createdTime);

        values.put(NoteColumns.MODIFIED_DATE, createdTime);

        // 设置笔记类型为普通笔记

        values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);

        // 标记笔记为本地修改

        values.put(NoteColumns.LOCAL_MODIFIED, 1);

        // 设置笔记所属的文件夹ID

        values.put(NoteColumns.PARENT_ID, folderId);

        // 向数据库插入新笔记，并获取其Uri

        Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);

 

        long noteId = 0;

        try {

            // 从Uri中提取新笔记的ID

            noteId = Long.valueOf(uri.getPathSegments().get(1));

        } catch (NumberFormatException e) {

            // 如果提取ID失败，则记录错误日志

            Log.e(TAG, "Get note id error :" + e.toString());

            noteId = 0;

        }

        // 如果ID为-1，则抛出异常

        if (noteId == -1) {

            throw new IllegalStateException("Wrong note id:" + noteId);

        }

        // 返回新笔记的ID

        return noteId;

    }

 

    // Note类的构造函数

    public Note() {

        // 初始化差异值存储和内容数据存储

        mNoteDiffValues = new ContentValues();

        mNoteData = new NoteData();

    }

 

    // 设置笔记的差异值

    public void setNoteValue(String key, String value) {

        mNoteDiffValues.put(key, value);

        // 标记笔记为本地修改

        mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);

        // 更新笔记的修改时间

        mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());

    }

 

    // 设置笔记的文本数据

    public void setTextData(String key, String value) {

        mNoteData.setTextData(key, value);

    }

 

    // 设置文本数据的ID

    public void setTextDataId(long id) {

        mNoteData.setTextDataId(id);

    }

 

    // 获取文本数据的ID

    public long getTextDataId() {

        return mNoteData.mTextDataId;

    }

 

    // 设置通话数据的ID

    public void setCallDataId(long id) {

        mNoteData.setCallDataId(id);

    }

 

    // 设置通话数据

    public void setCallData(String key, String value) {

        mNoteData.setCallData(key, value);

    }

 

    // 检查笔记是否有本地修改

    public boolean isLocalModified() {

        // 如果有差异值或内容数据有本地修改，则返回true

        return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();

    }

 

    // 同步笔记到数据库

    public boolean syncNote(Context context, long noteId) {

        // 检查笔记ID是否有效

        if (noteId <= 0) {

            throw new IllegalArgumentException("Wrong note id:" + noteId);

        }

 

        // 如果没有本地修改，则直接返回true

        if (!isLocalModified()) {

            return true;

        }

 

        // 更新笔记的差异值到数据库

        // 注意：即使更新失败，也会继续执行后续代码以确保数据安全性

        if (context.getContentResolver().update(

                ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,

                null) == 0) {

            // 如果更新失败，则记录错误日志

            Log.e(TAG, "Update note error, should not happen");

            // 不返回，继续执行

        }

        // 清空差异值存储，因为已经同步到数据库

        mNoteDiffValues.clear();

 

        // 如果内容数据有本地修改，则尝试将其同步到数据库

        if (mNoteData.isLocalModified()

                && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {

            // 如果同步失败，则返回false

            return false;

        }

 

        // 如果所有操作都成功，则返回true

        return true;

    }

}
    // 定义一个私有的内部类NoteData

private class NoteData {

    // 文本数据的ID

    private long mTextDataId;

 

    // 用于存储文本数据的ContentValues对象

    private ContentValues mTextDataValues;

 

    // 通话数据的ID

    private long mCallDataId;

 

    // 用于存储通话数据的ContentValues对象

    private ContentValues mCallDataValues;

 

    // 用于日志记录的标签

    private static final String TAG = "NoteData";

 

    // 构造函数，初始化成员变量

    public NoteData() {

        mTextDataValues = new ContentValues();

        mCallDataValues = new ContentValues();

        mTextDataId = 0;

        mCallDataId = 0;

    }

 

    // 检查本地数据是否被修改

    boolean isLocalModified() {

        return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;

    }

 

    // 设置文本数据的ID

    void setTextDataId(long id) {

        if(id <= 0) {

            // 如果ID小于等于0，抛出异常

            throw new IllegalArgumentException("Text data id should larger than 0");

        }

        mTextDataId = id;

    }

 

    // 设置通话数据的ID

    void setCallDataId(long id) {

        if (id <= 0) {

            // 如果ID小于等于0，抛出异常

            throw new IllegalArgumentException("Call data id should larger than 0");

        }

        mCallDataId = id;

    }

 

    // 设置通话数据

    void setCallData(String key, String value) {

        mCallDataValues.put(key, value);

        // 下面的两行代码似乎有误，因为mNoteDiffValues在类中未定义

        // mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);

        // mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());

    }

 

    // 设置文本数据

    void setTextData(String key, String value) {

        mTextDataValues.put(key, value);

        // 同样，下面的两行代码因为mNoteDiffValues未定义而存在问题

        // mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);

        // mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());

    }

 

    // 将数据推送到内容提供者

    Uri pushIntoContentResolver(Context context, long noteId) {

        // 检查noteId的有效性

        if (noteId <= 0) {

            throw new IllegalArgumentException("Wrong note id:" + noteId);

        }

 

        // 用于存储内容提供者操作的列表

        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();

        ContentProviderOperation.Builder builder = null;

 

        // 如果文本数据有变化

        if(mTextDataValues.size() > 0) {

            // 添加noteId到文本数据

            mTextDataValues.put(DataColumns.NOTE_ID, noteId);

            // 如果是新数据，插入新记录

            if (mTextDataId == 0) {

                mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);

                Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,

                        mTextDataValues);

                try {

                    // 从返回的URI中提取新插入的ID

                    setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));

                } catch (NumberFormatException e) {

                    // 如果提取ID失败，记录错误并清空数据

                    Log.e(TAG, "Insert new text data fail with noteId" + noteId);

                    mTextDataValues.clear();

                    return null;

                }

            } else {

                // 如果是已有数据，更新记录

                builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(

                        Notes.CONTENT_DATA_URI, mTextDataId));

                builder.withValues(mTextDataValues);

                operationList.add(builder.build());

            }

            // 清空已处理的数据

            mTextDataValues.clear();

        }

 

        // 如果通话数据有变化

        if(mCallDataValues.size() > 0) {

            // 添加noteId到通话数据

            mCallDataValues.put(DataColumns.NOTE_ID, noteId);

            // 如果是新数据，插入新记录

            if (mCallDataId == 0) {

                mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);

                Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,

                        mCallDataValues);

                try {

                    // 从返回的URI中提取新插入的ID

                    setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));

                } catch (NumberFormatException e) {

                    // 如果提取ID失败，记录错误并清空数据

                    Log.e(TAG, "Insert new call data fail with noteId" + noteId);

                    mCallDataValues.clear();

                    return null;

                }

            } else {

                // 如果是已有数据，更新记录

                builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(

                        Notes.CONTENT_DATA_URI, mCallDataId));

                builder.withValues(mCallDataValues);

                operationList.add(builder.build());

            }

            // 清空已处理的数据

            mCallDataValues.clear();

        }

 

        // 如果存在需要执行的操作

        if (operationList.size() > 0) {

            try {

                // 批量执行操作

                ContentProviderResult[] results = context.getContentResolver().applyBatch(

                        Notes.AUTHORITY, operationList);

                // 根据执行结果返回相应的URI

                return (results == null || results.length == 0 || results[0] == null) ? null

                        : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);

            } catch (RemoteException e) {

                // 捕获远程异常并记录

                Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));

                return null;

            } catch (OperationApplicationException e) {

                // 捕获操作应用异常并记录

                Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));

                return null;

            }

        }

        // 如果没有操作需要执行，返回null

        return null;

    }

}