use sea_orm_migration::prelude::*;

use crate::*;

#[derive(DeriveMigrationName)]
pub struct Migration;

#[async_trait::async_trait]
impl MigrationTrait for Migration {
    async fn up(&self, m: &SchemaManager) -> Result<(), DbErr> {
        self.create_stores(m).await?;
        self.create_store_currencies(m).await?;
        self.create_tax_providers(m).await?;
        self.create_tax_rates(m).await?;
        self.create_region_fulfillment_providers(m).await?;
        self.create_region_payment_providers(m).await?;

        Ok(())
    }

    async fn down(&self, m: &SchemaManager) -> Result<(), DbErr> {
        self.drop_table(m, Store::Stores).await?;
        self.drop_table(m, StoreCurrency::StoreCurrencies).await?;
        self.drop_table(m, TaxProvider::TaxProviders).await?;
        self.drop_table(m, TaxRate::TaxRates).await?;
        self.drop_table(m, RegionFulfillmentProvider::RegionFulfillmentProviders)
            .await?;
        self.drop_table(m, RegionPaymentProvider::RegionPaymentProviders)
            .await?;
        Ok(())
    }
}

impl Migration {
    /// ```sql
    /// CREATE TABLE stores
    /// (
    ///     id                       uuid                                                         NOT NULL,
    ///     name                     character varying        DEFAULT 'Bazaar'::character varying NOT NULL,
    ///     default_currency_code    character varying        DEFAULT 'pln'::character varying    NOT NULL,
    ///     swap_link_template       character varying,
    ///     created_at               timestamp with time zone DEFAULT now()                       NOT NULL,
    ///     updated_at               timestamp with time zone DEFAULT now()                       NOT NULL,
    ///     metadata                 jsonb,
    ///     payment_link_template    character varying,
    ///     invite_link_template     character varying,
    ///     default_sales_channel_id uuid,
    ///     default_location_id      uuid
    /// );
    /// ```
    async fn create_stores(&self, m: &SchemaManager<'_>) -> Result<(), DbErr> {
        use Store::*;

        m.build_table(
            Stores,
            &mut [
                Id.col().uuid().not_null().primary_key().default_gen_uuid(),
                Name.col().string().default("Bazzar".to_string()).not_null(),
                DefaultCurrencyCode.col().string().default("pln").not_null(),
                SwapLinkTemplate.col().string(),
                CreatedAt.col().timestamp().not_null().default_now(),
                UpdatedAt.col().timestamp().not_null().default_now(),
                Metadata.col().json_binary(),
                PaymentLinkTemplate.col().string(),
                InviteLinkTemplate.col().string(),
                DefaultSalesChannelId.col().uuid(),
                DefaultLocationId.col().uuid(),
            ],
        )
        .await?;

        Ok(())
    }

    /// ```sql
    /// CREATE TABLE store_currencies
    /// (
    ///     store_id      uuid              NOT NULL,
    ///     currency_code character varying NOT NULL
    /// );
    /// ```
    async fn create_store_currencies(&self, m: &SchemaManager<'_>) -> Result<(), DbErr> {
        use StoreCurrency::*;

        m.create_table(
            Table::create()
                .table(StoreCurrencies)
                .col(StoreId.col().uuid().not_null())
                .col(CurrencyCode.col().string().not_null())
                .primary_key(&mut m.bridge_primary_key(StoreCurrencies, StoreId, CurrencyCode))
                .to_owned(),
        )
        .await?;

        Ok(())
    }

    /// ```sql
    /// CREATE TABLE tax_providers
    /// (
    ///     id           uuid                 NOT NULL,
    ///     is_installed boolean DEFAULT true NOT NULL
    /// );
    /// ```
    async fn create_tax_providers(&self, m: &SchemaManager<'_>) -> Result<(), DbErr> {
        use TaxProvider::*;

        m.build_table(
            TaxProviders,
            &mut [
                Id.col().uuid().not_null().default_gen_uuid().primary_key(),
                IsInstalled.col().boolean().default(true).not_null(),
            ],
        )
        .await?;

        Ok(())
    }

    /// ```sql
    /// CREATE TABLE tax_rates
    /// (
    ///     id         uuid                                   NOT NULL,
    ///     rate       real,
    ///     code       character varying,
    ///     name       character varying                      NOT NULL,
    ///     region_id  uuid                                   NOT NULL,
    ///     created_at timestamp with time zone DEFAULT now() NOT NULL,
    ///     updated_at timestamp with time zone DEFAULT now() NOT NULL,
    ///     metadata   jsonb
    /// );
    /// ```
    async fn create_tax_rates(&self, m: &SchemaManager<'_>) -> Result<(), DbErr> {
        use TaxRate::*;

        m.build_table(
            TaxRates,
            &mut [
                Id.col().uuid().primary_key().default_gen_uuid(),
                Rate.col().double(),
                Code.col().string(),
                Name.col().string().not_null(),
                RegionId.col().uuid().not_null(),
                CreatedAt.col().timestamp().not_null().default_now(),
                UpdatedAt.col().timestamp().not_null().default_now(),
                Metadata.col().json_binary(),
            ],
        )
        .await?;
        Ok(())
    }

    /// ```sql
    /// CREATE TABLE region_fulfillment_providers
    /// (
    ///     region_id   uuid NOT NULL,
    ///     provider_id uuid NOT NULL
    /// );
    /// ```
    async fn create_region_fulfillment_providers(
        &self,
        m: &SchemaManager<'_>,
    ) -> Result<(), DbErr> {
        use RegionFulfillmentProvider::*;

        m.create_bridge_table(RegionFulfillmentProviders, RegionId, ProviderId)
            .await?;

        Ok(())
    }

    /// ```sql
    /// CREATE TABLE region_payment_providers
    /// (
    ///     region_id   uuid NOT NULL,
    ///     provider_id uuid NOT NULL
    /// );
    /// ```
    async fn create_region_payment_providers(&self, m: &SchemaManager<'_>) -> Result<(), DbErr> {
        use RegionPaymentProvider::*;

        m.create_bridge_table(RegionPaymentProviders, RegionId, ProviderId)
            .await?;

        Ok(())
    }
}

#[derive(Iden, Clone, Copy)]
pub enum Store {
    Stores,
    Id,
    Name,
    DefaultCurrencyCode,
    SwapLinkTemplate,
    CreatedAt,
    UpdatedAt,
    Metadata,
    PaymentLinkTemplate,
    InviteLinkTemplate,
    DefaultSalesChannelId,
    DefaultLocationId,
}

#[derive(Iden, Clone, Copy)]
pub enum StoreCurrency {
    StoreCurrencies,
    StoreId,
    CurrencyCode,
}

#[derive(Iden, Clone, Copy)]
pub enum TaxProvider {
    TaxProviders,
    Id,
    IsInstalled,
}

#[derive(Iden, Clone, Copy)]
pub enum TaxRate {
    TaxRates,
    Id,
    Rate,
    Code,
    Name,
    RegionId,
    CreatedAt,
    UpdatedAt,
    Metadata,
}

#[derive(Iden, Clone, Copy)]
pub enum RegionFulfillmentProvider {
    RegionFulfillmentProviders,
    RegionId,
    ProviderId,
}

#[derive(Iden, Clone, Copy)]
pub enum RegionPaymentProvider {
    RegionPaymentProviders,
    RegionId,
    ProviderId,
}