from fastapi import FastAPI

import logging

from ptc.models import ProjectManager

from fastapi import FastAPI

app = FastAPI()

from ptc.db_helpers import serialize_from_document, serialize_to_document
from ptc.exceptions import ProjectWasNotStarted, MoreThanOneLogOpenForProject, ProjectAlreadyStarted
from ptc.models import ProjectManager, Project, TimeLog, TimeLogManager

def serialize_project(project):
    project["_id"] = str(project["_id"])
    return project

logger = logging.getLogger(__name__)
app = FastAPI()

    return [serialize_project(p) for p in ProjectManager.list()]

    return [serialize_from_document(p) for p in ProjectManager.list()]

async def create_project():
    pass

async def create_project(project: Project):
    ProjectManager.create(project.dict(exclude_none=True))
    return project

async def start_project_timer(project_id: int):
    pass

async def start_project_timer(project_id: str):
    available_project_ids = [str(p["_id"]) for p in ProjectManager.list()]
    if project_id not in available_project_ids:
        return {"project_id": "This project id does not exist"}
    logs = list(TimeLogManager.list({"project_id": project_id, "end": None}))
    if logs:
        raise ProjectAlreadyStarted
    log = TimeLog(project_id=project_id)
    TimeLogManager.create(log.dict(exclude_none=True))
    return log

async def end_project_timer(project_id: int):
    pass

async def end_project_timer(project_id: str):
    logs = list(TimeLogManager.list({"project_id": project_id, "end": None}))
    if not logs:
        raise ProjectWasNotStarted
    if len(logs) > 1:
        raise MoreThanOneLogOpenForProject
    log = serialize_from_document(logs[0])
    logger.info(f"We got log {log}")
    log = TimeLog(**log)
    logger.info(f"Validated log: {log.dict()}")
    log.stop_timer()
    TimeLogManager.update(serialize_to_document(log.dict()))
    return log

import uuid

from .exceptions import LogIsStopped

        if not obj["_id"]:

        if not obj.get("_id"):

    def delete(cls, time_log: dict) -> bool:

    def delete(cls, obj_id: str) -> bool:

    _id: uuid.UUID = None

    id: str = None

    def stop_timer(self):
        if self.end:
            raise LogIsStopped
        self.end = datetime.utcnow()

    _id: uuid.UUID = None

    id: str = None

    time_logs: List[TimeLog] = []

class LogIsStopped(Exception):
    pass
class ProjectWasNotStarted(Exception):
    pass
class MoreThanOneLogOpenForProject(Exception):
    pass
class ProjectAlreadyStarted(Exception):
    pass

from bson.objectid import ObjectId
def serialize_from_document(document: dict) -> dict:
    document["id"] = str(document.pop("_id"))
    return document
def serialize_to_document(document: dict) -> dict:
    document["_id"] = ObjectId(document.pop("id"))
    return document

- [ ] "Create project" endpoint
- [ ] Start timer on project
- [ ] End timer on project

- [x] "Create project" endpoint
- [x] Start timer on project
- [x] End timer on project

- [ ] Add validation for multiple active timers

- [x] Add validation for multiple active timers