export async function processImageTask(req: { body: { imageUrl: string; filters: string[] } }) {
  const { imageUrl, filters } = req.body;
  try {
    const result = await processImage(imageUrl, filters);
    return { success: true, processedUrl: result.url };
  } catch (error) {
    console.error('Image processing failed:', error);
    throw error;
  }
}

type ImageProcessInput = {
  imageUrl: string;
  filters: string[];
};

type ImageProcessOutput = {
  processedUrl: string;
  metadata: {
    size: number;
    format: string;
    appliedFilters: string[];
  };
};

export const imageProcessor = hatchet.task({
  name: 'image-processor',
  retries: 3,
  executionTimeout: '10m',
  fn: async ({ imageUrl, filters }: ImageProcessInput): Promise<ImageProcessOutput> => {
    // Do some image processing
    const result = await processImage(imageUrl, filters);

    if (!result.url) throw new Error('Processing failed to generate URL');

    return {
      processedUrl: result.url,
      metadata: {
        size: result.size,
        format: result.format,
        appliedFilters: filters,
      },
    };
  },
});

async def process_image_task(request: Any) -> Dict[str, Any]:
    image_url = request.json["image_url"]
    filters = request.json["filters"]
    try:
        result = await process_image(image_url, filters)
        return {"success": True, "processed_url": result["url"]}
    except Exception as e:
        print(f"Image processing failed: {e}")
        raise

class ImageProcessInput(BaseModel):
    image_url: str
    filters: List[str]


class ImageProcessOutput(BaseModel):
    processed_url: str
    metadata: Dict[str, Any]


@hatchet.task(
    name="image-processor",
    retries=3,
    execution_timeout="10m",
    input_validator=ImageProcessInput,
)
async def image_processor(input: ImageProcessInput, ctx: Context) -> ImageProcessOutput:
    # Do some image processing
    result = await process_image(input.image_url, input.filters)

    if not result["url"]:
        raise ValueError("Processing failed to generate URL")

    return ImageProcessOutput(
        processed_url=result["url"],
        metadata={
            "size": result["size"],
            "format": result["format"],
            "applied_filters": input.filters,
        },
    )

type MergentRequest struct {
	ImageURL string   `json:"image_url"`
	Filters  []string `json:"filters"`
}

type MergentResponse struct {
	Success      bool   `json:"success"`
	ProcessedURL string `json:"processed_url"`
}

func ProcessImageMergent(req MergentRequest) (*MergentResponse, error) {
	result, err := ProcessImage(req.ImageURL, req.Filters)
	if err != nil {
		return nil, err
	}

	return &MergentResponse{
		Success:      true,
		ProcessedURL: result["url"].(string),
	}, nil
}

type ImageProcessInput struct {
	ImageURL string   `json:"image_url"`
	Filters  []string `json:"filters"`
}

type ImageProcessOutput struct {
	ProcessedURL string `json:"processed_url"`
	Metadata     struct {
		Size           int      `json:"size"`
		Format         string   `json:"format"`
		AppliedFilters []string `json:"applied_filters"`
	} `json:"metadata"`
}

func ImageProcessor(hatchet v1.HatchetClient) workflow.WorkflowDeclaration[ImageProcessInput, ImageProcessOutput] {
	processor := factory.NewTask(
		create.StandaloneTask{
			Name: "image-processor",
		},
		func(ctx worker.HatchetContext, input ImageProcessInput) (*ImageProcessOutput, error) {
			result, err := ProcessImage(input.ImageURL, input.Filters)
			if err != nil {
				return nil, fmt.Errorf("processing image: %w", err)
			}

			if result["url"] == "" {
				return nil, fmt.Errorf("processing failed to generate URL")
			}

			output := &ImageProcessOutput{
				ProcessedURL: result["url"].(string),
				Metadata: struct {
					Size           int      `json:"size"`
					Format         string   `json:"format"`
					AppliedFilters []string `json:"applied_filters"`
				}{
					Size:           result["size"].(int),
					Format:         result["format"].(string),
					AppliedFilters: input.Filters,
				},
			}

			return output, nil
		},
		hatchet,
	)

const options = {
  method: 'POST',
  headers: { Authorization: 'Bearer <token>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    name: '4cf95241-fa19-47ef-8a67-71e483747649',
    queue: 'default',
    request: {
      url: 'https://example.com',
      headers: { Authorization: 'fake-secret-token', 'Content-Type': 'application/json' },
      body: 'Hello, world!',
    },
  }),
};

fetch('https://api.mergent.co/v2/tasks', options)
  .then((response) => response.json())
  .then((response) => console.log(response))
  .catch((err) => console.error(err));

const result = await imageProcessor.run({
  imageUrl: 'https://example.com/image.png',
  filters: ['blur'],
});

// you can await fully typed results
console.log(result);

headers: Mapping[str, str] = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json",
}

task_data = {
    "name": "4cf95241-fa19-47ef-8a67-71e483747649",
    "queue": "default",
    "request": {
        "url": "https://example.com",
        "headers": {
            "Authorization": "fake-secret-token",
            "Content-Type": "application/json",
        },
        "body": "Hello, world!",
    },
}

try:
    response: Response = requests.post(
        "https://api.mergent.co/v2/tasks",
        headers=headers,
        json=task_data,
    )
    print(response.json())
except Exception as e:
    print(f"Error: {e}")

result = await image_processor.aio_run(
    ImageProcessInput(image_url="https://example.com/image.png", filters=["blur"])
)

# you can await fully typed results
print(result)

task := struct {
	Request struct {
		URL     string            `json:"url"`
		Body    string            `json:"body"`
		Headers map[string]string `json:"headers"`
	} `json:"request"`
	Name  string `json:"name"`
	Queue string `json:"queue"`
}{
	Request: struct {
		URL     string            `json:"url"`
		Body    string            `json:"body"`
		Headers map[string]string `json:"headers"`
	}{
		URL: "https://example.com",
		Headers: map[string]string{
			"Authorization": "fake-secret-token",
			"Content-Type":  "application/json",
		},
		Body: "Hello, world!",
	},
	Name:  "4cf95241-fa19-47ef-8a67-71e483747649",
	Queue: "default",
}

taskJSON, err := json.Marshal(task)
if err != nil {
	return fmt.Errorf("marshaling task: %w", err)
}

req, err := http.NewRequest(http.MethodPost, "https://api.mergent.co/v2/tasks", bytes.NewBuffer(taskJSON))
if err != nil {
	return fmt.Errorf("creating request: %w", err)
}

req.Header.Add("Authorization", "Bearer <API_KEY>")
req.Header.Add("Content-Type", "application/json")

client := &http.Client{}
res, err := client.Do(req)
if err != nil {
	return fmt.Errorf("sending request: %w", err)
}
defer res.Body.Close()

fmt.Printf("Mergent task created with status: %d\n", res.StatusCode)

processor := ImageProcessor(hatchet)

result, err := processor.Run(context.Background(), ImageProcessInput{
	ImageURL: "https://example.com/image.png",
	Filters:  []string{"blur"},
})
if err != nil {
	return err
}
fmt.Printf("Result: %+v\n", result)

const options = {
  // same options as before
  body: JSON.stringify({
    // same body as before
    delay: '5m',
  }),
};

// Schedule the task to run at a specific time
const runAt = new Date(Date.now() + 1000 * 60 * 60 * 24);
imageProcessor.schedule(runAt, {
  imageUrl: 'https://example.com/image.png',
  filters: ['blur'],
});

// Schedule the task to run every hour
imageProcessor.cron('run-hourly', '0 * * * *', {
  imageUrl: 'https://example.com/image.png',
  filters: ['blur'],
});

options = {
    # same options as before
    "json": {
        # same body as before
        "delay": "5m"
    }
}

# Schedule the task to run at a specific time
run_at = datetime.now() + timedelta(days=1)
await image_processor.aio_schedule(
    run_at,
    ImageProcessInput(image_url="https://example.com/image.png", filters=["blur"]),
)

# Schedule the task to run every hour
await image_processor.aio_create_cron(
    "run-hourly",
    "0 * * * *",
    ImageProcessInput(image_url="https://example.com/image.png", filters=["blur"]),
)

// Schedule the task to run at a specific time
scheduleRef, err := processor.Schedule(
	context.Background(),
	time.Now().Add(time.Second*10),
	ImageProcessInput{
		ImageURL: "https://example.com/image.png",
		Filters:  []string{"blur"},
	},
)
if err != nil {
	return err
}

// or schedule to run every hour
cronRef, err := processor.Cron(
	context.Background(),
	"run-hourly",
	"0 * * * *",
	ImageProcessInput{
		ImageURL: "https://example.com/image.png",
		Filters:  []string{"blur"},
	},
)