from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import Optional

import uvicorn


app = FastAPI()


class Bar(BaseModel):
    bar_bar_1: str = Field(
        None, alias="bar:bar-1"
    )
    bar_bar_2: Optional[str] = Field(
        None, alias="bar:bar-2"
    )

    class Config:
        allow_population_by_field_name = True


# Model for OpenAPI schema representation
class BarProxy(BaseModel):
    bar_bar_1: str
    bar_bar_2: Optional[str]


class Foo(BaseModel):
    foo_bar_1: str = Field(
        None, alias="foo:bar-1"
    )
    foo_bar_2: Optional[str] = Field(
        None, alias="foo:bar-2"
    )
    foo_bar_3: Optional[Bar] = Field(
        None, alias="foo:bar-3"
    )

    class Config:
        allow_population_by_field_name = True


# Model for OpenAPI schema representation
class FooProxy(BaseModel):
    foo_bar_1: str
    foo_bar_2: Optional[str]
    foo_bar_3: Optional[BarProxy]


# Data consists of full model inclusively field aliases
data = [
    Foo(foo_bar_1="field1", foo_bar_2="field2", foo_bar_3=Bar(bar_bar_1="bar_field1", bar_bar_2="bar_field2")),
]


@app.get(
    "/foo/{obj_id}",
    response_model=FooProxy,
)
def get_foo(obj_id: int):
    if obj_id > len(data) - 1 or obj_id < 0:
        raise HTTPException(status_code=404, detail="Item not found")
    print("Representation of full model:")
    print(data[obj_id].dict(by_alias=True))
    # With .dict(by_alias=False) FastAPI easily convert the Foo-Model into the FooProxy-Model
    return data[obj_id].dict(by_alias=False)


@app.post(
    "/foo",
    status_code=201,
    response_model=FooProxy,
)
def create_foo(obj: FooProxy):
    data.append(Foo(**obj.dict()))
    print("Representation of full model:")
    print(data[-1].dict(by_alias=True))
    # With .dict(by_alias=False) FastAPI easily convert the Foo-Model into the FooProxy-Model
    return data[-1].dict(by_alias=False)

class Foo(BaseModel):
    foo_bar_1: int
    foo_bar_2: str

    @root_validator(pre=True)
    def alias_values(cls, values):
        '''
        Assigning alias in order for swagger docs to display correct schema keys
        '''
        values['foo_bar_1'] = values.pop("incoming_key_foo_bar_1")
        values['foo_bar_2'] = values.pop("incoming_key_foo_bar_2")
        return values

class MyModel(BaseModel):
    my_attribute: str = Field(..., alias="myAttribute")

    class Config:
        allow_population_by_field_name = True

        # The schema is generated by default using aliases as keys.
        # We want the snake_case name output.
        # Modified from:
        # - https://pydantic-docs.helpmanual.io/usage/schema/#schema-customization
        @staticmethod
        def schema_extra(schema: Dict[str, Any], model: Type['Person']) -> None:
            snake_case = {}

            for field in model.__fields__.values():
                k = field.name
                v = schema['properties'][field.alias]
                snake_case.update({k: v})

            schema.update({'properties': snake_case})

def without_alias(model, *, recursively=False):
    """Create a fantom model without alias.

    This is used to not exposed internal aliases to fasapi.

    Example :

    _model.py_
    ```python
    MyModelWithoutAliases = without_alias(MyModel, recursively=True)
    ```
    _router.py_
    ```python
    from model import MyModelWithoutAliases as MyModel
    @router.post(..., response_model=MyModel)
    ```
    """
    monkey_model = deepcopy(model)
    for name, field in monkey_model.__fields__.items():
        if field.alias != name:
            field.alias = name
            field.field_info.alias = name
            field.field_info.alias_priority = 1

        if issubclass(field.type_, APIModel) and recursively:
            field.type_ = without_alias(field.type_, recursively=recursively)

    return monkey_model