use sea_orm_migration::prelude::*;

pub struct Migration;

impl MigrationName for Migration {
    fn name(&self) -> &str {
        "m_20230730_000001_create_repo_tables"
    }
}

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .create_table(
                Table::create()
                    .table(Distro::Table)
                    .col(
                        ColumnDef::new(Distro::Id)
                            .integer()
                            .not_null()
                            .auto_increment()
                            .primary_key(),
                    )
                    .col(
                        ColumnDef::new(Distro::Name)
                            .string()
                            .not_null()
                            .unique_key(),
                    )
                    .col(ColumnDef::new(Distro::Description).string())
                    .to_owned(),
            )
            .await?;
        manager
            .create_table(
                Table::create()
                    .table(Repo::Table)
                    .col(
                        ColumnDef::new(Repo::Id)
                            .integer()
                            .not_null()
                            .auto_increment()
                            .primary_key(),
                    )
                    .col(ColumnDef::new(Repo::DistroId).integer().not_null())
                    .col(ColumnDef::new(Repo::Name).string().not_null().unique_key())
                    .col(ColumnDef::new(Repo::Description).string())
                    .foreign_key(
                        ForeignKey::create()
                            .name("fk-repo-distro_id")
                            .from(Repo::Table, Repo::DistroId)
                            .to(Distro::Table, Distro::Id)
                            .on_delete(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;
        manager
            .create_table(
                Table::create()
                    .table(Package::Table)
                    .col(
                        ColumnDef::new(Package::Id)
                            .integer()
                            .not_null()
                            .auto_increment()
                            .primary_key(),
                    )
                    .col(ColumnDef::new(Package::RepoId).integer().not_null())
                    .col(ColumnDef::new(Package::Base).string_len(255).not_null())
                    .col(ColumnDef::new(Package::Name).string_len(255).not_null())
                    .col(ColumnDef::new(Package::Version).string_len(255).not_null())
                    .col(ColumnDef::new(Package::Arch).string_len(255).not_null())
                    .col(ColumnDef::new(Package::Size).big_integer().not_null())
                    .col(ColumnDef::new(Package::CSize).big_integer().not_null())
                    .col(ColumnDef::new(Package::Description).string())
                    .col(ColumnDef::new(Package::Url).string_len(255))
                    .col(ColumnDef::new(Package::BuildDate).date_time().not_null())
                    .col(ColumnDef::new(Package::Packager).string_len(255))
                    .col(ColumnDef::new(Package::PgpSig).string_len(255))
                    .col(ColumnDef::new(Package::PgpSigSize).big_integer())
                    .col(ColumnDef::new(Package::Sha256Sum).char_len(64).not_null())
                    .col(
                        ColumnDef::new(Package::Compression)
                            .string_len(16)
                            .not_null(),
                    )
                    .col(ColumnDef::new(Package::State).integer().not_null())
                    .foreign_key(
                        ForeignKey::create()
                            .name("fk-package-repo_id")
                            .from(Package::Table, Package::RepoId)
                            .to(Repo::Table, Repo::Id)
                            .on_delete(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;
        manager
            .create_table(
                Table::create()
                    .table(PackageLicense::Table)
                    .col(
                        ColumnDef::new(PackageLicense::PackageId)
                            .integer()
                            .not_null(),
                    )
                    .col(
                        ColumnDef::new(PackageLicense::Name)
                            .string_len(255)
                            .not_null(),
                    )
                    .primary_key(
                        Index::create()
                            .col(PackageLicense::PackageId)
                            .col(PackageLicense::Name),
                    )
                    .foreign_key(
                        ForeignKey::create()
                            .name("fk-package_license-package_id")
                            .from(PackageLicense::Table, PackageLicense::PackageId)
                            .to(Package::Table, Package::Id)
                            .on_delete(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;
        manager
            .create_table(
                Table::create()
                    .table(PackageGroup::Table)
                    .col(ColumnDef::new(PackageGroup::PackageId).integer().not_null())
                    .col(
                        ColumnDef::new(PackageGroup::Name)
                            .string_len(255)
                            .not_null(),
                    )
                    .primary_key(
                        Index::create()
                            .col(PackageGroup::PackageId)
                            .col(PackageGroup::Name),
                    )
                    .foreign_key(
                        ForeignKey::create()
                            .name("fk-package_group-package_id")
                            .from(PackageGroup::Table, PackageGroup::PackageId)
                            .to(Package::Table, Package::Id)
                            .on_delete(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;
        manager
            .create_table(
                Table::create()
                    .table(PackageRelated::Table)
                    .col(
                        ColumnDef::new(PackageRelated::PackageId)
                            .integer()
                            .not_null(),
                    )
                    .col(ColumnDef::new(PackageRelated::Type).integer().not_null())
                    .col(
                        ColumnDef::new(PackageRelated::Name)
                            .string_len(255)
                            .not_null(),
                    )
                    .primary_key(
                        Index::create()
                            .col(PackageRelated::PackageId)
                            .col(PackageRelated::Type)
                            .col(PackageRelated::Name),
                    )
                    .foreign_key(
                        ForeignKey::create()
                            .name("fk-package_depends-package_id")
                            .from(PackageRelated::Table, PackageRelated::PackageId)
                            .to(Package::Table, Package::Id)
                            .on_delete(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;
        manager
            .create_table(
                Table::create()
                    .table(PackageFile::Table)
                    .col(ColumnDef::new(PackageFile::PackageId).integer().not_null())
                    .col(ColumnDef::new(PackageFile::Path).string_len(255).not_null())
                    .primary_key(
                        Index::create()
                            .col(PackageFile::PackageId)
                            .col(PackageFile::Path),
                    )
                    .foreign_key(
                        ForeignKey::create()
                            .name("fk-package_file-package_id")
                            .from(PackageFile::Table, PackageFile::PackageId)
                            .to(Package::Table, Package::Id)
                            .on_delete(ForeignKeyAction::Cascade),
                    )
                    .to_owned(),
            )
            .await?;

        Ok(())
    }

    // Define how to rollback this migration: Drop the Bakery table.
    async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
        manager
            .drop_table(Table::drop().table(PackageLicense::Table).to_owned())
            .await?;
        manager
            .drop_table(Table::drop().table(PackageGroup::Table).to_owned())
            .await?;
        manager
            .drop_table(Table::drop().table(PackageRelated::Table).to_owned())
            .await?;
        manager
            .drop_table(Table::drop().table(PackageFile::Table).to_owned())
            .await?;
        manager
            .drop_table(Table::drop().table(Package::Table).to_owned())
            .await?;
        manager
            .drop_table(Table::drop().table(Repo::Table).to_owned())
            .await?;
        manager
            .drop_table(Table::drop().table(Distro::Table).to_owned())
            .await
    }
}

#[derive(Iden)]
pub enum Distro {
    Table,
    Id,
    Name,
    Description,
}

#[derive(Iden)]
pub enum Repo {
    Table,
    Id,
    DistroId,
    Name,
    Description,
}

#[derive(Iden)]
pub enum Package {
    Table,
    Id,
    RepoId,
    Name,
    Base,
    Version,
    Description,
    Size,
    CSize,
    Url,
    Arch,
    BuildDate,
    Packager,
    PgpSig,
    PgpSigSize,
    Sha256Sum,
    Compression,
    State,
}

#[derive(Iden)]
pub enum PackageLicense {
    Table,
    PackageId,
    Name,
}

#[derive(Iden)]
pub enum PackageGroup {
    Table,
    PackageId,
    Name,
}

#[derive(Iden)]
pub enum PackageRelated {
    Table,
    PackageId,
    Type,
    Name,
}

#[derive(Iden)]
pub enum PackageFile {
    Table,
    PackageId,
    Path,
}