//CloudObject.ts
export class CloudObject {
    className: string;
    id: string | null = null;
    createdAt:any;
    updatedAt:any;
    data: Record<string, any> = {};

    constructor(className: string) {
        this.className = className;
    }

    toPointer() {
        return { "__type": "Pointer", "className": this.className, "objectId": this.id };
    }

    set(json: Record<string, any>) {
        Object.keys(json).forEach(key => {
            if (["objectId", "id", "createdAt", "updatedAt", "ACL"].indexOf(key) > -1) {
                return;
            }
            this.data[key] = json[key];
        });
    }

    get(key: string) {
        return this.data[key] || null;
    }

    async save() {
        let method = "POST";
        let url = `http://dev.fmode.cn:1337/parse/classes/${this.className}`;

        // 更新
        if (this.id) {
            url += `/${this.id}`;
            method = "PUT";
        }

        const body = JSON.stringify(this.data);
        const response = await fetch(url, {
            headers: {
                "content-type": "application/json;charset=UTF-8",
                "x-parse-application-id": "dev"
            },
            body: body,
            method: method,
            mode: "cors",
            credentials: "omit"
        });

        const result = await response?.json();
        if (result?.error) {
            console.error(result?.error);
        }
        if (result?.objectId) {
            this.id = result?.objectId;
        }
        return this;
    }

    async destroy() {
        if (!this.id) return;
        const response = await fetch(`http://dev.fmode.cn:1337/parse/classes/${this.className}/${this.id}`, {
            headers: {
                "x-parse-application-id": "dev"
            },
            body: null,
            method: "DELETE",
            mode: "cors",
            credentials: "omit"
        });

        const result = await response?.json();
        if (result) {
            this.id = null;
        }
        return true;
    }
}

// CloudQuery.ts
export class CloudQuery {
    className: string;
    whereOptions: Record<string, any> = {};

    constructor(className: string) {
        this.className = className;
    }
    include(...fields: string[]) {
        this.whereOptions["include"] = fields;
    }
    greaterThan(key: string, value: any) {
        if (!this.whereOptions["where"]) this.whereOptions["where"] = {};
        if (!this.whereOptions["where"][key]) this.whereOptions["where"][key] = {};
        this.whereOptions["where"][key]["$gt"] = value;
    }

    greaterThanAndEqualTo(key: string, value: any) {
        if (!this.whereOptions["where"]) this.whereOptions["where"] = {};
        if (!this.whereOptions["where"][key]) this.whereOptions["where"][key] = {};
        this.whereOptions["where"][key]["$gte"] = value;
    }

    lessThan(key: string, value: any) {
        if (!this.whereOptions["where"]) this.whereOptions["where"] = {};
        if (!this.whereOptions["where"][key]) this.whereOptions["where"][key] = {};
        this.whereOptions["where"][key]["$lt"] = value;
    }

    lessThanAndEqualTo(key: string, value: any) {
        if (!this.whereOptions["where"]) this.whereOptions["where"] = {};
        if (!this.whereOptions["where"][key]) this.whereOptions["where"][key] = {};
        this.whereOptions["where"][key]["$lte"] = value;
    }

    equalTo(key: string, value: any) {
        if (!this.whereOptions["where"]) this.whereOptions["where"] = {};
        this.whereOptions["where"][key] = value;
        return this;
    }

    async get(id: string) {
        const url = `http://dev.fmode.cn:1337/parse/classes/${this.className}/${id}?`;

        const response = await fetch(url, {
            headers: {
                "if-none-match": "W/\"1f0-ghxH2EwTk6Blz0g89ivf2adBDKY\"",
                "x-parse-application-id": "dev"
            },
            body: null,
            method: "GET",
            mode: "cors",
            credentials: "omit"
        });

        const json = await response?.json();
        return json || {};
    }

    async find(): Promise<Array<CloudObject>>{
        let url = `http://dev.fmode.cn:1337/parse/classes/${this.className}?`;

        // 构建查询字符串
        let queryStr = '';
        Object.keys(this.whereOptions).forEach(key => {
            let paramStr = JSON.stringify(this.whereOptions[key]);
            if (key === "include") {
                paramStr = this.whereOptions[key]?.join(","); // 将数组转换为逗号分隔字符串
            }
            // 添加查询参数到 URL
            if (queryStr) {
                url += `&${key}=${paramStr}`;
            } else {
                url += `${key}=${paramStr}`;
            }
        });

        const response = await fetch(url, {
            headers: {
                "if-none-match": "W/\"1f0-ghxH2EwTk6Blz0g89ivf2adBDKY\"",
                "x-parse-application-id": "dev"
            },
            body: null,
            method: "GET",
            mode: "cors",
            credentials: "omit"
        });

        const json = await response?.json();
        let list = json?.results || []
        let objList = list.map((item:any)=>this.dataToObj(item))
        return objList || [];
    }

    async first() {
        let url = `http://dev.fmode.cn:1337/parse/classes/${this.className}?`;

        if (Object.keys(this.whereOptions).length) {
            const whereStr = JSON.stringify(this.whereOptions);
            url += `where=${whereStr}`;
        }

        const response = await fetch(url, {
            headers: {
                "if-none-match": "W/\"1f0-ghxH2EwTk6Blz0g89ivf2adBDKY\"",
                "x-parse-application-id": "dev"
            },
            body: null,
            method: "GET",
            mode: "cors",
            credentials: "omit"
        });

        const json = await response?.json();
        const exists = json?.results?.[0] || null;
        if (exists) {
            let existsObject = this.dataToObj(exists)
            return existsObject;
        }
        return null
    }

    //使得页面上获得的数据是由CloudObject构成的
    dataToObj(exists:any):CloudObject{
        let existsObject = new CloudObject(this.className);
        existsObject.set(exists);
        existsObject.id = exists.objectId;
        existsObject.createdAt = exists.createdAt;
        existsObject.updatedAt = exists.updatedAt;
        return existsObject;
    }
}

// CloudUser.ts
export class CloudUser extends CloudObject {
    sessionToken: string | null = ""; // 用户的 sessionToken，用于身份验证

    constructor() {
        super("_User"); // 调用父类构造函数，指定类名为 "User"

        // 读取用户缓存信息
        let userCacheStr = localStorage.getItem("NCloud/dev/User");
        if (userCacheStr) {
            let userData = JSON.parse(userCacheStr);
            // 设置用户信息
            this.id = userData?.objectId; // 设置用户 ID
            this.sessionToken = userData?.sessionToken; // 设置 sessionToken
            this.data = userData; // 保存用户数据
        }
    }

    /** 获取当前用户信息 */
    async current() {
        // 检查用户是否登录
        if (!this.sessionToken) {
            console.error("用户未登录");
            return null; // 如果未登录，返回 null
        }
        return this;
        
    //     // 发送 GET 请求以获取当前用户信息
    //     const response = await fetch(`http://dev.fmode.cn:1337/parse/users/me`, {
    //         headers: {
    //             "x-parse-application-id": "dev",
    //             "x-parse-session-token": this.sessionToken // 使用 sessionToken 进行身份验证
    //         },
    //         method: "GET"
    //     });

    //     const result = await response?.json(); // 解析响应
    //     if (result?.error) {
    //         console.error(result?.error); // 处理错误
    //         return null;
    //     }
    //     return result; // 返回用户信息
    
     }

    /** 登录 */
    async login(username: string, password: string): Promise<CloudUser | null> {
        // 发送 POST 请求以进行用户登录
        const response = await fetch(`http://dev.fmode.cn:1337/parse/login`, {
            headers: {
                "x-parse-application-id": "dev",
                "Content-Type": "application/json"
            },
            body: JSON.stringify({ username, password }), // 登录凭据
            method: "POST"
        });

        const result = await response?.json(); // 解析响应
        if (result?.error) {
            console.error(result?.error); // 处理错误
            return null;
        }
        
        // 设置用户信息
        this.id = result?.objectId; // 设置用户 ID
        this.sessionToken = result?.sessionToken; // 设置 sessionToken
        this.data = result; // 保存用户数据

        // 缓存用户信息到 localStorage
        console.log(result);
        localStorage.setItem("NCloud/dev/User", JSON.stringify(result));
        return this; // 返回当前用户实例
    }

    /** 登出 */
    async logout() {
        // 检查用户是否登录
        if (!this.sessionToken) {
            console.error("用户未登录");
            return;
        }

        // 发送 POST 请求以进行用户登出
        const response = await fetch(`http://dev.fmode.cn:1337/parse/logout`, {
            headers: {
                "x-parse-application-id": "dev",
                "x-parse-session-token": this.sessionToken // 使用 sessionToken 进行身份验证
            },
            method: "POST"
        });

        const result = await response?.json(); // 解析响应
        if (result?.error) {
            console.error(result?.error); // 处理错误
            return false; // 登出失败
        }

        // 清除用户信息
        localStorage.removeItem("NCloud/dev/User"); // 从 localStorage 中移除用户信息
        this.id = null; // 清除用户 ID
        this.sessionToken = null; // 清除 sessionToken
        this.data = {}; // 清空用户数据
        return true; // 登出成功
    }

    /** 注册 */
    async signUp(username: string, password: string, additionalData: Record<string, any> = {}) {
        // 构建用户数据
        const userData = {
            username,
            password,
            ...additionalData // 合并额外的用户数据
        };

        // 发送 POST 请求以进行用户注册
        const response = await fetch(`http://dev.fmode.cn:1337/parse/users`, {
            headers: {
                "x-parse-application-id": "dev",
                "Content-Type": "application/json"
            },
            body: JSON.stringify(userData), // 注册凭据
            method: "POST"
        });

        const result = await response?.json(); // 解析响应
        if (result?.error) {
            console.error(result?.error); // 处理错误
            return null; // 注册失败
        }

        // 设置用户信息
        this.id = result?.objectId; // 设置用户 ID
        this.sessionToken = result?.sessionToken; // 设置 sessionToken
        this.data = result; // 保存用户数据
        return this; // 返回当前用户实例
    }

    //覆盖save方法
    override async save() {
        let method = "POST";
        let url = `http://dev.fmode.cn:1337/parse/users`;
    
        // 更新用户信息
        if (this.id) {
            url += `/${this.id}`;
            method = "PUT";
        }
    
        let data:any = JSON.parse(JSON.stringify(this.data))
        delete data.createdAt
        delete data.updatedAt
        delete data.ACL
        delete data.objectId
        const body = JSON.stringify(data);
        let headersOptions:any = {
            "content-type": "application/json;charset=UTF-8",
            "x-parse-application-id": "dev",
            "x-parse-session-token": this.sessionToken, // 添加sessionToken以进行身份验证
        }
        const response = await fetch(url, {
            headers: headersOptions,
            body: body,
            method: method,
            mode: "cors",
            credentials: "omit"
        });
    
        const result = await response?.json();
        if (result?.error) {
            console.error(result?.error);
        }
        if (result?.objectId) {
            this.id = result?.objectId;
        }
        localStorage.setItem("NCloud/dev/User",JSON.stringify(this.data))
        return this;
    }
}

//CloudPost.ts
interface PostData {
    title: string; // 标题属性
    content: string; // 内容属性
    [key: string]: any; // 其他任意属性
}

export class CloudPost extends CloudObject {
    constructor() {
        super('FilmPost'); // 调用父类构造函数，指定类名
    }

    // 设置帖子数据，包括发布者信息
    setPostData(postData: PostData, userId: string | null) {
        // 确保 title 和 content 是必需的
        if (!postData.title || !postData.content) {
            throw new Error('Both title and content are required.');
        }

        this.set(postData); // 设置帖子内容
        this.data["author"] = { "__type": "Pointer", "className": "_User", "objectId": userId }; // 设置发布者信息
    }

    // 点赞帖子
    async likePost() {
    }

    // 更新帖子数据
    async updatePost(postData: PostData) {
        // 确保 title 和 content 是必需的
        if (!postData.title || !postData.content) {
            throw new Error('Both title and content are required.');
        }

        this.set(postData); // 更新帖子内容
        return await this.save(); // 保存更新
    }

    // 删除帖子
    async deletePost() {
        return await this.destroy(); // 调用父类的 destroy 方法
    }
}


// CloudComment.ts
interface CommentData {
    content: string; // 评论内容
    postId: string; // 关联的帖子 ID
    [key: string]: any; // 其他任意属性
}

export class CloudComment extends CloudObject {
    constructor() {
        super('FilmPostComment'); // 调用父类构造函数，指定类名
    }
        // 设置评论数据，包括发布者和关联的帖子
        setCommentData(CommentData: CommentData, userId: string | null) {
            // 确保 title 和 content 是必需的
            if (!CommentData.postId || !CommentData.content) {
                throw new Error('Both post and content are required.');
            }
    
            this.set(CommentData); // 设置帖子内容
            this.data["user"] = { "__type": "Pointer", "className": "_User", "objectId": userId }; // 设置发布者信息
            this.data["post"] = { "__type": "Pointer", "className": "FilmPost", "objectId": CommentData.postId }; // 设置关联的帖子信息
        }
    

   // 创建评论
   async createComment(commentData: CommentData, userId: string | null) {
    this.setCommentData(commentData, userId);
    try {
        const savedComment = await this.save();
        return savedComment; // 返回保存的评论
    } catch (error) {
        console.error("Error creating comment:", error);
        throw error; // 重新抛出错误
    }
}

// 更新帖子评论计数
 async updatePostCommentCount(postId: string, increment: number) {
    const postQuery = new CloudQuery('FilmPost');
    const post = await postQuery.get(postId);
    if (!post) {
        console.error(`Post with ID ${postId} not found.`);
        throw new Error(`Post with ID ${postId} not found.`);
    }
    // 确保 post.data 存在 commentCount 属性
    if (typeof post.data["commentCount"] === 'undefined') {
        console.warn(`commentCount property is undefined for postId: ${postId}. Initializing to 0.`);
        post.data["commentCount"] = 0; // 初始化为 0
    }
    
    post.data["commentCount"] = Math.max((post.data["commentCount"] || 0) + increment, 0); // 更新评论计数
    const result = await post.save(); // 保存更新后的帖子
    console.log("Post updated successfully:", result);
}

// 更新评论
async updateComment(commentData: CommentData) {
    if (!this.id) {
        throw new Error('Comment ID is required for updating.');
    }

    this.set(commentData); // 更新评论内容
    return await this.save(); // 保存更新
}

// 删除评论
async deleteComment() {
    if (!this.id) {
        throw new Error('Comment ID is required for deletion.');
    }

    // 获取关联的帖子并更新评论计数
    return await this.destroy(); // 调用父类的 destroy 方法
}

// 查询评论
async findComments(postId: string) {

}
}


//CloudFeedback.ts
interface FeedbackData {
    feedback: string; // 内容属性
    [key: string]: any; // 其他任意属性
}

export class CloudFeedback extends CloudObject {
    constructor() {
        super('FilmFeedback'); // 调用父类构造函数，指定类名
    }

    // 设置反馈数据，包括发布者信息
    setFeedbackData(feedbackData: FeedbackData, userId: string | null) {
        // 确保 feedback 是必需的
        if (!feedbackData.feedback) {
            throw new Error('feedback is required.');
        }

        this.set(feedbackData); // 设置帖子内容
        this.data["user"] = { "__type": "Pointer", "className": "_User", "objectId": userId }; // 设置发布者信息
    }

    // 更新帖子数据
    async updateFeedback(feedbackData: FeedbackData) {
        // 确保 feedback 是必需的
         if (!feedbackData.feedback) {
            throw new Error('feedback is required.');
        }

        this.set(feedbackData); // 更新反馈内容
        return await this.save(); // 保存更新
    }

    // 删除反馈
    async deleteFeedback() {
        return await this.destroy(); // 调用父类的 destroy 方法
    }
}