use sea_orm_migration::{
    prelude::{extension::postgres::Type, *},
    schema::*,
    sea_orm::{EnumIter, Iterable},
};

#[derive(DeriveIden)]
enum Users {
    Table,
    Id,
    Username,
    PasswordHash,
    PasswordIssueDate,
    FirstName,
    LastName,
}

#[derive(DeriveIden)]
enum Queues {
    Table,
    Id,
    OwnerId,
    Name,
}

#[derive(DeriveIden)]
enum InviteTokens {
    Table,
    Id,
    Token,
    QueueId,
}

#[derive(DeriveIden)]
enum AccessToQueue {
    Table,
    UserId,
    QueueId,
}

#[derive(DeriveIden)]
enum QueueElements {
    Table,
    Id,
    QueueId,
    UserId,
    Position,
    Status,
}

mod queue_element_status {
    use super::*;

    #[derive(DeriveIden)]
    #[sea_orm(iden = "queue_element_status_enum")]
    pub struct Iden;

    #[derive(Iden, EnumIter)]
    pub enum Items {
        Passed,
        Waiting,
    }
}

#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .create_table(
                Table::create()
                    .table(Users::Table)
                    .if_not_exists()
                    .col(pk_auto(Users::Id).big_integer())
                    .col(string(Users::Username).unique_key())
                    .col(string(Users::PasswordHash))
                    .col(timestamp(Users::PasswordIssueDate))
                    .col(string(Users::FirstName))
                    .col(string(Users::LastName))
                    .to_owned(),
            )
            .await?;

        manager
            .create_table(
                Table::create()
                    .table(Queues::Table)
                    .if_not_exists()
                    .col(pk_auto(Queues::Id).big_integer())
                    .col(big_integer(Queues::OwnerId))
                    .foreign_key(
                        ForeignKey::create()
                            .from(Queues::Table, Queues::OwnerId)
                            .to(Users::Table, Users::Id)
                            .on_delete(ForeignKeyAction::Cascade)
                            .on_update(ForeignKeyAction::Cascade),
                    )
                    .col(string(Queues::Name))
                    .to_owned(),
            )
            .await?;

        manager
            .create_table(
                Table::create()
                    .table(InviteTokens::Table)
                    .if_not_exists()
                    .col(pk_auto(InviteTokens::Id).big_integer())
                    .col(uuid(InviteTokens::Token))
                    .col(big_integer(InviteTokens::QueueId))
                    .foreign_key(
                        ForeignKey::create()
                            .from(InviteTokens::Table, InviteTokens::QueueId)
                            .to(Queues::Table, Queues::Id)
                            .on_delete(ForeignKeyAction::Cascade)
                            .on_update(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;

        manager
            .create_table(
                Table::create()
                    .table(AccessToQueue::Table)
                    .if_not_exists()
                    .col(big_integer(AccessToQueue::UserId))
                    .col(big_integer(AccessToQueue::QueueId))
                    .foreign_key(
                        ForeignKey::create()
                            .from(AccessToQueue::Table, AccessToQueue::UserId)
                            .to(Users::Table, Users::Id)
                            .on_delete(ForeignKeyAction::Cascade)
                            .on_update(ForeignKeyAction::Cascade),
                    )
                    .foreign_key(
                        ForeignKey::create()
                            .from(AccessToQueue::Table, AccessToQueue::QueueId)
                            .to(Queues::Table, Queues::Id)
                            .on_delete(ForeignKeyAction::Cascade)
                            .on_update(ForeignKeyAction::Cascade),
                    )
                    .primary_key(
                        Index::create()
                            .col(AccessToQueue::UserId)
                            .col(AccessToQueue::QueueId),
                    )
                    .to_owned(),
            )
            .await?;

        manager
            .create_type(
                Type::create()
                    .as_enum(queue_element_status::Iden)
                    .values(queue_element_status::Items::iter())
                    .to_owned(),
            )
            .await?;

        manager
            .create_table(
                Table::create()
                    .table(QueueElements::Table)
                    .if_not_exists()
                    .col(pk_auto(QueueElements::Id).big_integer())
                    .col(big_integer(QueueElements::QueueId))
                    .col(big_integer(QueueElements::UserId))
                    .col(
                        big_integer(QueueElements::Position)
                            .unique_key()
                            .auto_increment(),
                    )
                    .col(enumeration(
                        QueueElements::Status,
                        queue_element_status::Iden,
                        queue_element_status::Items::iter(),
                    ))
                    .foreign_key(
                        ForeignKey::create()
                            .from(QueueElements::Table, QueueElements::UserId)
                            .to(Users::Table, Users::Id)
                            .on_delete(ForeignKeyAction::Cascade)
                            .on_update(ForeignKeyAction::Cascade),
                    )
                    .foreign_key(
                        ForeignKey::create()
                            .from(QueueElements::Table, QueueElements::QueueId)
                            .to(Queues::Table, Queues::Id)
                            .on_delete(ForeignKeyAction::Cascade)
                            .on_update(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;

        Ok(())
    }

    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .drop_table(Table::drop().table(Users::Table).to_owned())
            .await?;

        manager
            .drop_table(Table::drop().table(Queues::Table).to_owned())
            .await?;

        manager
            .drop_table(Table::drop().table(AccessToQueue::Table).to_owned())
            .await?;

        manager
            .drop_table(Table::drop().table(QueueElements::Table).to_owned())
            .await?;

        Ok(())
    }
}