yss-project/src/app/services/urgent-task.service.ts

import { Injectable } from '@angular/core';
import { FmodeParse } from 'fmode-ng/parse';

/**
 * 紧急事项服务
 * 负责UrgentTask的CRUD操作，对接Parse Server数据库
 */
@Injectable({
  providedIn: 'root'
})
export class UrgentTaskService {
  private Parse = FmodeParse.with("nova");
  private companyId = localStorage.getItem("company")!;
  private currentUserId = localStorage.getItem("profile")!;

  constructor() {}

  /**
   * 查询紧急事项列表（带筛选和分页）
   */
  async findUrgentTasks(filters?: {
    status?: string;
    priority?: string;
    assignee?: string;
    projectId?: string;
    isCompleted?: boolean;
  }, page: number = 1, pageSize: number = 20): Promise<{ tasks: any[], total: number }> {
    try {
      const query = this.buildUrgentTaskQuery(filters);
      
      // 分页
      query.limit(pageSize);
      query.skip((page - 1) * pageSize);
      
      // Include关联数据
      query.include("project");
      query.include("assignee");
      query.include("creator");
      query.include("space");
      
      // 排序：优先级高的在前，截止时间早的在前
      query.descending("priority");
      query.ascending("deadline");
      
      const [tasks, total] = await Promise.all([
        query.find(),
        query.count()
      ]);

      // 如果没有数据，直接返回空数组
      if (!tasks || tasks.length === 0) {
        console.log('紧急事项暂无数据');
        return { tasks: [], total: 0 };
      }

      // 格式化数据
      const formattedTasks = tasks.map(t => this.formatTask(t));

      return { tasks: formattedTasks, total };
    } catch (error) {
      console.error('查询紧急事项列表失败:', error);
      return { tasks: [], total: 0 };
    }
  }

  /**
   * 构建查询条件
   */
  private buildUrgentTaskQuery(filters?: any) {
    try {
      const UrgentTask = this.Parse.Object.extend("UrgentTask");
      const query = new this.Parse.Query(UrgentTask);
      
      query.equalTo("company", this.getCompanyPointer());
      query.notEqualTo("isDeleted", true);
    
      if (filters) {
        // 完成状态
        if (filters.isCompleted !== undefined) {
          query.equalTo("isCompleted", filters.isCompleted);
        }
        
        // 任务状态
        if (filters.status) {
          query.equalTo("status", filters.status);
        }
        
        // 优先级
        if (filters.priority) {
          query.equalTo("priority", filters.priority);
        }
        
        // 指派人
        if (filters.assignee) {
          query.equalTo("assignee", this.getProfilePointer(filters.assignee));
        }
        
        // 项目ID
        if (filters.projectId) {
          query.equalTo("project", this.getProjectPointer(filters.projectId));
        }
      }
    
      return query;
    } catch (error) {
      console.error('构建查询条件失败:', error);
      const UrgentTask = this.Parse.Object.extend("UrgentTask");
      const query = new this.Parse.Query(UrgentTask);
      query.equalTo("company", this.getCompanyPointer());
      return query;
    }
  }

  /**
   * 格式化单个任务数据
   */
  private formatTask(taskObj: any) {
    const project = taskObj.get("project");
    const assignee = taskObj.get("assignee");
    const creator = taskObj.get("creator");
    const space = taskObj.get("space");
    const deadline = taskObj.get("deadline");
    const now = new Date();

    return {
      id: taskObj.id,
      title: taskObj.get("title") || "",
      description: taskObj.get("description") || "",
      projectId: project?.id || "",
      projectName: project?.get("title") || "",
      spaceId: space?.id || "",
      spaceName: space?.get("title") || "",
      stage: taskObj.get("stage") || "",
      region: taskObj.get("region") || "",
      priority: taskObj.get("priority") || "medium",
      status: taskObj.get("status") || "pending",
      assigneeId: assignee?.id || "",
      assigneeName: assignee?.get("name") || "未分配",
      creatorId: creator?.id || "",
      creatorName: creator?.get("name") || "",
      deadline: deadline,
      isOverdue: deadline ? deadline < now : false,
      isCompleted: taskObj.get("isCompleted") || false,
      createdAt: taskObj.get("createdAt"),
      updatedAt: taskObj.get("updatedAt"),
      data: taskObj.get("data") || {}
    };
  }

  /**
   * 创建紧急事项
   */
  async createUrgentTask(taskData: {
    title: string;
    description?: string;
    projectId: string;
    spaceId?: string;
    stage: string;
    region?: string;
    priority: string;
    assigneeId?: string;
    deadline: Date;
  }): Promise<any> {
    try {
      const UrgentTask = this.Parse.Object.extend("UrgentTask");
      const task = new UrgentTask();
      
      task.set("company", this.getCompanyPointer());
      task.set("creator", this.getCurrentProfilePointer());
      task.set("title", taskData.title);
      task.set("description", taskData.description || "");
      task.set("project", this.getProjectPointer(taskData.projectId));
      
      if (taskData.spaceId) {
        task.set("space", this.getSpacePointer(taskData.spaceId));
      }
      
      task.set("stage", taskData.stage);
      task.set("region", taskData.region || "");
      task.set("priority", taskData.priority);
      task.set("deadline", taskData.deadline);
      task.set("status", "pending");
      task.set("isCompleted", false);
      task.set("isDeleted", false);
      
      if (taskData.assigneeId) {
        task.set("assignee", this.getProfilePointer(taskData.assigneeId));
      }
      
      const savedTask = await task.save();
      console.log('✅ 紧急事项创建成功:', savedTask.id);
      
      return this.formatTask(savedTask);
    } catch (error) {
      console.error('❌ 创建紧急事项失败:', error);
      throw error;
    }
  }

  /**
   * 更新紧急事项
   */
  async updateUrgentTask(taskId: string, updates: {
    title?: string;
    description?: string;
    stage?: string;
    region?: string;
    priority?: string;
    assigneeId?: string;
    deadline?: Date;
    status?: string;
    isCompleted?: boolean;
  }): Promise<any> {
    try {
      const UrgentTask = this.Parse.Object.extend("UrgentTask");
      const query = new this.Parse.Query(UrgentTask);
      const task = await query.get(taskId);
      
      if (updates.title !== undefined) task.set("title", updates.title);
      if (updates.description !== undefined) task.set("description", updates.description);
      if (updates.stage !== undefined) task.set("stage", updates.stage);
      if (updates.region !== undefined) task.set("region", updates.region);
      if (updates.priority !== undefined) task.set("priority", updates.priority);
      if (updates.deadline !== undefined) task.set("deadline", updates.deadline);
      if (updates.status !== undefined) task.set("status", updates.status);
      if (updates.isCompleted !== undefined) task.set("isCompleted", updates.isCompleted);
      
      if (updates.assigneeId !== undefined) {
        task.set("assignee", this.getProfilePointer(updates.assigneeId));
      }
      
      const savedTask = await task.save();
      console.log('✅ 紧急事项更新成功:', savedTask.id);
      
      return this.formatTask(savedTask);
    } catch (error) {
      console.error('❌ 更新紧急事项失败:', error);
      throw error;
    }
  }

  /**
   * 删除紧急事项（软删除）
   */
  async deleteUrgentTask(taskId: string): Promise<void> {
    try {
      const UrgentTask = this.Parse.Object.extend("UrgentTask");
      const query = new this.Parse.Query(UrgentTask);
      const task = await query.get(taskId);
      
      task.set("isDeleted", true);
      await task.save();
      
      console.log('✅ 紧急事项删除成功:', taskId);
    } catch (error) {
      console.error('❌ 删除紧急事项失败:', error);
      throw error;
    }
  }

  /**
   * 标记任务为已完成
   */
  async markAsCompleted(taskId: string): Promise<any> {
    return this.updateUrgentTask(taskId, {
      isCompleted: true,
      status: 'completed'
    });
  }

  /**
   * 获取项目列表（用于下拉选择）
   */
  async getProjects(): Promise<any[]> {
    try {
      const Project = this.Parse.Object.extend("Project");
      const query = new this.Parse.Query(Project);
      query.equalTo("company", this.getCompanyPointer());
      query.notEqualTo("isDeleted", true);
      query.limit(1000);
      // 不使用select，获取所有字段
      
      const projects = await query.find();
      
      return projects.map(p => ({
        id: p.id,
        title: p.get("title") || "未命名项目",
        stage: p.get("currentStage") || "",
        status: p.get("status") || ""
      }));
    } catch (error) {
      console.error('获取项目列表失败:', error);
      return [];
    }
  }

  /**
   * 获取项目的空间列表（Product表）
   */
  async getProjectSpaces(projectId: string): Promise<any[]> {
    try {
      const Product = this.Parse.Object.extend("Product");
      const query = new this.Parse.Query(Product);
      query.equalTo("project", this.getProjectPointer(projectId));
      query.equalTo("company", this.getCompanyPointer());
      query.notEqualTo("isDeleted", true);
      query.limit(100);
      // 不使用select，获取所有字段
      
      const products = await query.find();
      
      return products.map(p => ({
        id: p.id,
        title: p.get("title") || "未命名空间"
      }));
    } catch (error) {
      console.error('获取空间列表失败:', error);
      return [];
    }
  }

  /**
   * 获取团队成员列表（用于指派）
   */
  async getTeamMembers(): Promise<any[]> {
    try {
      const Profile = this.Parse.Object.extend("Profile");
      const query = new this.Parse.Query(Profile);
      query.equalTo("company", this.getCompanyPointer());
      query.notEqualTo("isDeleted", true);
      query.limit(1000);
      // 不使用select，获取所有字段
      
      const profiles = await query.find();
      
      return profiles.map(p => ({
        id: p.id,
        name: p.get("name") || "未命名",
        mobile: p.get("mobile") || "",
        roleName: p.get("roleName") || ""
      }));
    } catch (error) {
      console.error('获取团队成员列表失败:', error);
      return [];
    }
  }

  // ==================== 辅助方法 ====================

  private getCompanyPointer() {
    return {
      __type: "Pointer",
      className: "Company",
      objectId: this.companyId
    };
  }

  private getCurrentProfilePointer() {
    return {
      __type: "Pointer",
      className: "Profile",
      objectId: this.currentUserId
    };
  }

  private getProfilePointer(profileId: string) {
    return {
      __type: "Pointer",
      className: "Profile",
      objectId: profileId
    };
  }

  private getProjectPointer(projectId: string) {
    return {
      __type: "Pointer",
      className: "Project",
      objectId: projectId
    };
  }

  private getSpacePointer(spaceId: string) {
    return {
      __type: "Pointer",
      className: "Product",
      objectId: spaceId
    };
  }
}