# frozen_string_literal: true

# 任务相关路由
module TaskRoutes
  def self.registered(app)
    # 任务列表页面 (Vue)
    app.get '/tasks' do
      @active_page = 'tasks'
      erb :tasks, layout: true
    end

    # 任务详情页面 (Vue)
    app.get '/tasks/:id/vue' do
      @task = LocalTask[params[:id]]
      halt 404, '任务不存在' unless @task
      @active_page = 'tasks'
      @task_id = @task.id
      erb :task_detail, layout: true
    end

    # 任务编辑页面
    app.get '/tasks/:id/edit' do
      @task = LocalTask[params[:id]]
      halt 404, '任务不存在' unless @task
      @active_page = 'tasks'
      @task_id = @task.id
      erb :task_edit, layout: true
    end

    app.get '/tasks/:id' do
      @task = LocalTask[params[:id]]

      # 重定向到 Vue 版本的任务详情页面
      redirect "/tasks/#{params[:id]}/vue"
    end

    app.post '/tasks/natural' do
      natural_language = params[:natural_language]
      cloud_client = CloudClient.instance

      begin
        # 1. 先同步本地设备到云端
        LogService.info("自然语言生成任务：开始同步本地设备到云端")
        sync_result = cloud_client.sync_devices
        if sync_result[:success]
          LogService.info("设备同步完成：成功 #{sync_result[:synced]} 个")
        else
          LogService.warn("设备同步失败：#{sync_result[:error]}，继续执行任务生成")
        end

        # 2. 发送到云端AI处理生成任务
        LogService.info("自然语言生成任务：调用云端AI生成任务")
        result = cloud_client.create_task_from_natural_language(
          natural_language: natural_language
        )
        LogService.info("云端返回结果: #{JSON.pretty_generate(result) rescue result.inspect}")

        if result[:success]
          # 3. 创建本地任务
          LogService.info("自然语言生成任务：创建本地任务，task_definition: #{result[:task_definition].inspect[0..2000]}")
          task = LocalTask.create_from_cloud_definition(result[:task_definition])
          LogService.info("自然语言生成任务：本地任务创建成功，任务ID: #{task.id}")

          # 4. 同步脚本到本地（确保任务需要的脚本都已同步）
          LogService.info("自然语言生成任务：同步脚本到本地")
          begin
            # 获取上次同步时间
            last_sync_setting = SystemSetting.find_or_create(key: 'last_script_sync_time')
            since = last_sync_setting.value

            # 从云端获取脚本
            cloud_scripts = cloud_client.get_scripts_for_sync(since: since)

            # 处理每个脚本
            cloud_scripts.each do |cloud_script|
              CachedScript.create_or_update_from_cloud(cloud_script)
            end

            # 更新同步时间
            last_sync_setting.update(value: Time.now.iso8601)
            LogService.info("脚本同步完成：共处理 #{cloud_scripts.size} 个脚本")
          rescue StandardError => e
            LogService.warn("脚本同步失败：#{e.message}，但任务仍可执行")
          end

          redirect "/tasks/#{task.id}/vue"
        else
          @error = result[:error]
          @devices = LocalDevice.all
          redirect '/tasks'
        end
      rescue StandardError => e
        LogService.error("自然语言生成任务异常：#{e.message}")
        @error = e.message
        redirect '/tasks'
      end
    end

    # 获取任务列表 API
    app.get '/api/tasks' do
      content_type :json
      tasks = LocalTask.order(Sequel.desc(:created_at)).all
      tasks.map(&:to_api_hash).to_json
    end
    # 获取单个任务详情 API
    app.get '/api/tasks/:id' do
      content_type :json
      task = LocalTask[params[:id]]
      halt 404, { error: '任务不存在' }.to_json unless task
      task.to_api_hash.to_json
    end

    # 调试端点：检查内存中的任务状态
    app.get '/api/v1/tasks/:id/debug' do
      content_type :json
      task = LocalTask[params[:id]]
      halt 404, { error: '任务不存在' }.to_json unless task

      latest_exec = task.latest_execution
      mem_task = latest_exec ? TaskExecutionManager.instance.get_task(latest_exec.id) : nil

      {
        pid: Process.pid,
        task_id: task.id,
        latest_execution_id: latest_exec&.id,
        has_mem_task: !mem_task.nil?,
        mem_task: mem_task,
        db_status: latest_exec&.status,
        db_progress: latest_exec&.progress,
        all_running_tasks: TaskExecutionManager.instance.get_all_running_tasks.keys,
        state_manager_object_id: TaskExecutionManager.instance.object_id
      }.to_json
    end

    # 带版本前缀的 API 路由（为了兼容性）
    app.get '/api/v1/tasks/:id' do
      content_type :json
      task = LocalTask[params[:id]]
      halt 404, { error: '任务不存在' }.to_json unless task
      task.to_api_hash.to_json
    end

    # 重置任务 API
    app.post '/api/v1/tasks/:id/reset' do
      content_type :json
      task = LocalTask[params[:id]]
      halt 404, { error: '任务不存在' }.to_json unless task
      
      begin
        task.reset!
        { success: true, message: '任务已重置' }.to_json
      rescue StandardError => e
        halt 500, { error: "重置失败: #{e.message}" }.to_json
      end
    end
    
    # 更新任务信息 API
    app.put '/api/v1/tasks/:id' do
      content_type :json
      task = LocalTask[params[:id]]
      halt 404, { error: '任务不存在' }.to_json unless task

      begin
        data = JSON.parse(request.body.read)
        task.update(name: data['name']) if data['name']
        task.update(description: data['description']) if data['description']
        task.update(task_definition: data['task_definition']) if data['task_definition']
        # 保存未选择的字段
        task.update(unselected_device_ids: data['unselected_device_ids']) if data.key?('unselected_device_ids')
        task.update(unselected_script_ids: data['unselected_script_ids']) if data.key?('unselected_script_ids')
        task.to_api_hash.to_json
      rescue StandardError => e
        halt 400, { error: "更新失败: #{e.message}" }.to_json
      end
    end
  end
end
