import json
import os
import uuid
import logging

from datetime import datetime, timezone

import boto3

logger = logging.getLogger()
logger.setLevel(logging.INFO)

dynamodb = boto3.resource("dynamodb")

TABLE_NAME = os.environ.get("TABLE_NAME", "Tasks")

table = dynamodb.Table(TABLE_NAME)

def response(status_code, body):
return {
"statusCode": status_code,
"headers": {
"Content-Type": "application/json"
},
"body": json.dumps(body)
}

def create_task(event):
try:
body = json.loads(event.get("body") or "{}")
except json.JSONDecodeError:
return response(400, {
"message": "JSON inválido."
})

title = body.get("title")

if not title:
return response(400, {
"message": "O campo 'title' é obrigatório."
})

task = {
"id": str(uuid.uuid4()),
"title": title,
"description": body.get("description", ""),
"done": False,
"createdAt": datetime.now(timezone.utc).isoformat()
}

table.put_item(Item=task)

logger.info("Task criada: %s", task["id"])

return response(201, task)

def list_tasks():
result = table.scan()

return response(200, {
"items": result.get("Items", [])
})

def get_task(task_id):
result = table.get_item(
Key={
"id": task_id
}
)

task = result.get("Item")

if not task:
return response(404, {
"message": "Tarefa não encontrada."
})

return response(200, task)

def update_task(task_id, event):
existing = table.get_item(
Key={
"id": task_id
}
).get("Item")

if not existing:
return response(404, {
"message": "Tarefa não encontrada."
})

try:
body = json.loads(event.get("body") or "{}")
except json.JSONDecodeError:
return response(400, {
"message": "JSON inválido."
})

allowed_fields = [
"title",
"description",
"done"
]

updates = {
key: value
for key, value in body.items()
if key in allowed_fields
}

if not updates:
return response(400, {
"message": "Nenhum campo válido informado."
})

expression_parts = []
expression_values = {}
expression_names = {}

for index, (key, value) in enumerate(updates.items()):
name_placeholder = f"#field{index}"
value_placeholder = f":value{index}"

expression_parts.append(
f"{name_placeholder} = {value_placeholder}"
)

expression_names[name_placeholder] = key
expression_values[value_placeholder] = value

result = table.update_item(
Key={
"id": task_id
},
UpdateExpression="SET " + ", ".join(expression_parts),
ExpressionAttributeNames=expression_names,
ExpressionAttributeValues=expression_values,
ReturnValues="ALL_NEW"
)

logger.info("Task atualizada: %s", task_id)

return response(
200,
result["Attributes"]
)

def delete_task(task_id):
existing = table.get_item(
Key={
"id": task_id
}
).get("Item")

if not existing:
return response(404, {
"message": "Tarefa não encontrada."
})

table.delete_item(
Key={
"id": task_id
}
)

logger.info("Task excluída: %s", task_id)

return response(200, {
"message": "Tarefa excluída com sucesso."
})

def lambda_handler(event, context):
logger.info("Request recebida")

try:
http = event["requestContext"]["http"]

method = http["method"]
path = event.get("rawPath", "")

if method == "POST" and path == "/tasks":
return create_task(event)

if method == "GET" and path == "/tasks":
return list_tasks()

task_id = (
event.get("pathParameters") or {}
).get("id")

if task_id:
if method == "GET":
return get_task(task_id)

if method == "PUT":
return update_task(task_id, event)

if method == "DELETE":
return delete_task(task_id)

return response(404, {
"message": "Rota não encontrada."
})

except Exception:
logger.exception(
"Erro inesperado durante processamento da requisição"
)

return response(500, {
"message": "Erro interno do servidor."
})