import type { VariablesContext } from "../middlewares.ts";
import { WorkflowEngine } from "../utils/workflow_engine.ts";

export async function createWorkOrder(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const orderData = await c.req.json();
    
    const [id] = await apiClient.database.table('work_orders').insert({
      ...orderData,
      status: 'pending',
      created_at: apiClient.database.fn.now(),
      updated_at: apiClient.database.fn.now()
    });
    
    const [order] = await apiClient.database.table('work_orders')
      .where('id', id)
      .select();
      
    return c.json({ data: order });
  } catch (error) {
    return c.json({ error: "创建工作单失败" }, 500);
  }
}

export async function getWorkOrders(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { status, assigneeId } = c.req.query();
    
    let query = apiClient.database.table('work_orders');
    
    if (status) {
      query = query.where('status', status);
    }
    
    if (assigneeId) {
      query = query.where('assignee_id', assigneeId);
    }
    
    const orders = await query.select();
    return c.json({ data: orders });
  } catch (error) {
    return c.json({ error: "获取工作单列表失败" }, 500);
  }
}

export async function getWorkOrderDetail(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { id } = c.req.param();
    
    const [order] = await apiClient.database.table('work_orders')
      .where('id', id)
      .select();
      
    if (!order) {
      return c.json({ error: 'Work order not found' }, 404);
    }
    
    return c.json({ data: order });
  } catch (error) {
    return c.json({ error: "获取工作单详情失败" }, 500);
  }
}

export async function updateWorkOrder(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { id } = c.req.param();
    const updateData = await c.req.json();
    
    await apiClient.database.table('work_orders')
      .where('id', id)
      .update({
        ...updateData,
        updated_at: apiClient.database.fn.now()
      });
      
    const [order] = await apiClient.database.table('work_orders')
      .where('id', id)
      .select();
      
    return c.json({ data: order });
  } catch (error) {
    return c.json({ error: "更新工作单失败" }, 500);
  }
}

export async function changeWorkOrderStatus(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { id } = c.req.param();
    const { status, comment } = await c.req.json();
    const user = c.get('user');
    if (!user || typeof user !== 'object' || !('id' in user) || !('roles' in user)) {
      return c.json({ error: "未授权访问" }, 401);
    }
    const userRoles = String(user.roles).split(',');
    const workOrderId = parseInt(id);
    const userId = Number(user.id);
    
    // 获取当前工单状态
    const [order] = await apiClient.database.table('work_orders')
      .where('id', id)
      .select();
    
    if (!order) {
      return c.json({ error: '工单不存在' }, 404);
    }

    // 初始化工作流引擎
    const workflow = new WorkflowEngine(c);
    
    // 检查状态流转是否允许
    const canTransition = await workflow.canTransition(
      order.status,
      status,
      userRoles
    );
    
    if (!canTransition) {
      return c.json({
        error: `不允许从${order.status}状态变更为${status}状态`
      }, 403);
    }

    // 更新工单状态
    const updateData: Record<string, any> = {
      status,
      updated_at: apiClient.database.fn.now()
    };
    
    // 如果是关闭操作，记录关闭人和关闭时间
    if (status === 'closed') {
      updateData.closer_id = userId;
      updateData.close_time = apiClient.database.fn.now();
    }
    
    await apiClient.database.table('work_orders')
      .where('id', id)
      .update(updateData);

    // 记录状态变更历史
    await workflow.logStatusChange(
      parseInt(id),
      order.status,
      status,
      Number(user.id),
      comment
    );
    
    // 记录流程操作历史
    if (status === 'closed') {
      await apiClient.database.table('work_order_process_history').insert({
        work_order_id: workOrderId,
        action_type: 'close',
        operator_id: userId,
        operate_time: apiClient.database.fn.now(),
        comment
      });
    }

    // 检查超时状态
    await workflow.checkTimeout(parseInt(id));

    return c.json({ data: { success: true } });
  } catch (error) {
    console.error('状态变更失败:', error);
    return c.json({ error: "更新工作单状态失败" }, 500);
  }
}

export async function getWorkOrderStatusHistory(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { id } = c.req.param();
    
    const history = await apiClient.database.table('work_order_status_history')
      .where('work_order_id', id)
      .orderBy('created_at', 'desc')
      .select();
      
    return c.json({ data: history });
  } catch (error) {
    return c.json({ error: "获取状态历史失败" }, 500);
  }
}

export async function assignWorkOrder(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { id } = c.req.param();
    const { assigneeId, comment } = await c.req.json();
    const user = c.get('user');
    if (!user || typeof user !== 'object' || !('id' in user)) {
      return c.json({ error: "未授权访问" }, 401);
    }
    const userId = Number(user.id);
    
    // 获取当前工单信息
    const [order] = await apiClient.database.table('work_orders')
      .where('id', id)
      .select();
      
    if (!order) {
      return c.json({ error: '工单不存在' }, 404);
    }

    const isReassign = order.assignee_id !== null;
    const updateData: Record<string, any> = {
      assignee_id: assigneeId,
      updated_at: apiClient.database.fn.now()
    };
    
    if (isReassign) {
      updateData.reassignee_id = userId;
      updateData.reassign_time = apiClient.database.fn.now();
    } else {
      updateData.assign_time = apiClient.database.fn.now();
    }
    
    await apiClient.database.table('work_orders')
      .where('id', id)
      .update(updateData);
      
    // 记录流程操作历史
    await apiClient.database.table('work_order_process_history').insert({
      work_order_id: parseInt(id),
      action_type: isReassign ? 'reassign' : 'assign',
      operator_id: userId,
      operate_time: apiClient.database.fn.now(),
      comment
    });
      
    return c.json({ data: { success: true } });
  } catch (error) {
    return c.json({ error: "分配工作单失败" }, 500);
  }
}

export async function getWorkflowDetails(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const { id } = c.req.param();
    
    // 获取工单基本信息
    const [order] = await apiClient.database.table('work_orders')
      .where('id', id)
      .select();
      
    if (!order) {
      return c.json({ error: '工单不存在' }, 404);
    }
    
    // 获取流程历史记录
    const processHistory = await apiClient.database.table('work_order_process_history')
      .where('work_order_id', id)
      .orderBy('operate_time', 'desc')
      .select();
    
    // 获取状态变更历史
    const statusHistory = await apiClient.database.table('work_order_status_history')
      .where('work_order_id', id)
      .orderBy('change_time', 'desc')
      .select();
    
    return c.json({
      data: {
        ...order,
        processHistory,
        statusHistory
      }
    });
  } catch (error) {
    return c.json({ error: "获取工单流程详情失败" }, 500);
  }
}

export async function getWorkOrderSettings(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    
    const settings = await apiClient.database.table('work_order_settings')
      .select();
      
    return c.json({ data: settings });
  } catch (error) {
    return c.json({ error: "获取工作单设置失败" }, 500);
  }
}

export async function updateWorkOrderSettings(c: VariablesContext) {
  try {
    const apiClient = c.get('apiClient');
    const settings = await c.req.json();
    
    await apiClient.database.table('work_order_settings')
      .update(settings);
      
    return c.json({ data: { success: true } });
  } catch (error) {
    return c.json({ error: "更新工作单设置失败" }, 500);
  }
}