from sanic_security.configuration import config

config.SECRET = "This is a big secret. Shhhhh"
config["CAPTCHA_FONT"] = "./resources/captcha-font.ttf"

create_initial_admin_account(app)
if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8000)

@app.post("api/security/register")
async def on_register(request):
    account = await register(request)
    two_step_session = await request_two_step_verification(request, account)
    await email_code(
        account.email, two_step_session.code  # Code = AJ8HGD
    )  # Custom method for emailing verification code.
    response = json(
        "Registration successful! Email verification required.",
        two_step_session.json,
    )
    two_step_session.encode(response)
    return response

@app.post("api/security/verify")
async def on_verify(request):
    two_step_session = await verify_account(request)
    return json("You have verified your account and may login!", two_step_session.json)

@app.post("api/security/login")
async def on_login(request):
    authentication_session = await login(request, require_second_factor=True)
    two_step_session = await request_two_step_verification(
        request, authentication_session.bearer
    )
    await email_code(
        authentication_session.bearer.email, two_step_session.code  # Code = BG5KLP
    )  # Custom method for emailing verification code.
    response = json(
        "Login successful! Two-factor authentication required.",
        authentication_session.json,
    )
    authentication_session.encode(response)
    two_step_session.encode(response)
    return response

@app.post("api/security/fulfill-2fa")
async def on_two_factor_authentication(request):
    authentication_session = await fulfill_second_factor(request)
    response = json(
        "Authentication session second-factor fulfilled! You are now authenticated.",
        authentication_session.json,
    )
    authentication_session.encode(response)
    return response

@app.post("api/security/logout")
async def on_logout(request):
    authentication_session = await logout(request)
    response = json("Logout successful!", authentication_session.json)
    return response

@app.post("api/security/auth")
async def on_authenticate(request):
    authentication_session = await authenticate(request)
    return json(
        "You have been authenticated.",
        authentication_session.json,
    )

@app.post("api/security/auth")
@requires_authentication
async def on_authenticate(request):
    return json(
        "You have been authenticated.",
        request.ctx.authentication_session.json,
    )

@app.get("api/security/captcha")
async def on_captcha_img_request(request):
    captcha_session = await request_captcha(request)
    response = captcha_session.get_image()  # Captcha: FV9NMQ
    captcha_session.encode(response)
    return response

@app.post("api/security/captcha")
async def on_captcha(request):
    captcha_session = await captcha(request)
    return json("Captcha attempt successful!", captcha_session.json)

@app.post("api/security/captcha")
@requires_captcha
async def on_captcha(request):
    return json("Captcha attempt successful!", request.ctx.captcha_session.json)

@app.post("api/security/two-step/request")
async def on_two_step_request(request):
    two_step_session = await request_two_step_verification(request)
    await email_code(
        two_step_session.bearer.email, two_step_session.code  # Code = DT6JZX
    )  # Custom method for emailing verification code.
    response = json("Verification request successful!", two_step_session.json)
    two_step_session.encode(response)
    return response

@app.post("api/security/two-step/resend")
async def on_two_step_resend(request):
    two_step_session = await TwoStepSession.decode(request)
    await email_code(
        two_step_session.bearer.email, two_step_session.code  # Code = DT6JZX
    )  # Custom method for emailing verification code.
    return json("Verification code resend successful!", two_step_session.json)

@app.post("api/security/two-step")
async def on_two_step_verification(request):
    two_step_session = await two_step_verification(request)
    response = json("Two-step verification attempt successful!", two_step_session.json)
    return response

@app.post("api/security/two-step")
@requires_two_step_verification
async def on_two_step_verification(request):
    response = json(
        "Two-step verification attempt successful!",
        request.ctx.two_step_session.json,
    )
    return response

await assign_role(
    "Chat Room Moderator",
    account,
    "channels:view,delete, account:suspend,mute, voice:*",
    "Can read and delete messages in all chat rooms, suspend and mute accounts, and control voice chat.",
)

@app.post("api/security/perms")
async def on_check_perms(request):
    authentication_session = await check_permissions(
        request, "channels:view", "voice:*"
    )
    return text("Account is authorized.")

@app.post("api/security/perms")
@require_permissions("channels:view", "voice:*")
async def on_check_perms(request):
    return text("Account is authorized.")

@app.post("api/security/roles")
async def on_check_roles(request):
    authentication_session = await check_roles(request, "Chat Room Moderator")
    return text("Account is authorized.")

@app.post("api/security/roles")
@require_roles("Chat Room Moderator")
async def on_check_roles(request):
    return text("Account is authorized.")

async def init():
    await Tortoise.init(
        db_url="sqlite://db.sqlite3",
        modules={"models": ["sanic_security.models", "app.models"]},
    )
    await Tortoise.generate_schemas()

register_tortoise(
    app,
    db_url="sqlite://db.sqlite3",
    modules={"models": ["sanic_security.models", "app.models"]},
    generate_schemas=True,
)

from tortoise.models import Model
from tortoise import fields


class Tournament(Model):
    id = fields.IntField(pk=True)
    name = fields.TextField()

# Create instance by save
tournament = Tournament(name="New Tournament")
await tournament.save()

# Or by .create()
await Tournament.create(name="Another Tournament")

# Now search for a record
tour = await Tournament.filter(name__contains="Another").first()
print(tour.name)