import { Sequelize } from 'sequelize';
import dotenv from 'dotenv';
dotenv.config();

let sequelize = createConnection();

// Supply Line Models
import supplyLine from './supplyLine/supplyLine.js';
import volumePrices from './supplyLine/volumePrices.js';

// Conf Models
import clientConfig from './conf/clientConfig.js';
import sequenceNumber from './conf/sequenceNumber.js';

// Supplier Models
import suppliers from './supplier/suppliers.js';
import connections from './supplier/connections.js';

// TradeItem Models
import tradeItem from './tradeItem/tradeItem.js';
import botanicalNames from './tradeItem/botanicalNames.js';
import countryOfOriginIsoCodes from './tradeItem/countryOfOriginIsoCodes.js';
import packageModel from './tradeItem/package.js';
import packingConfigurations from './tradeItem/packingConfigurations.js';
import photos from './tradeItem/photos.js';
import seasonalPeriod from './tradeItem/seasonalPeriod.js';
import characteristics from './tradeItem/characteristics.js';




/**
 * Contains all the models that are related to the application.
 * 
 * @example
 * models.@modelName@.findAll();
 * 
 * @example
 * models.tradeItem.findAll().then((data) => {
 *    console.log(data);
 * });
 * 
 * @example
 * models.tradeItem.create({
 *   tradeItemName: 'Test',
 *   foo: 'bar',
 * });
 * 
 * 
 * @type {Object.<string, Sequelize.Model>}
 */
let models = {
    sequelize: sequelize,
    tradeItem: tradeItem(sequelize),
    packingConfiguration: packingConfigurations(sequelize),
    photo: photos(sequelize),
    characteristic: characteristics(sequelize),
    countryOfOriginIsoCode: countryOfOriginIsoCodes(sequelize),
    package: packageModel(sequelize),
    seasonalPeriod: seasonalPeriod(sequelize),
    clientConfig: clientConfig(sequelize),
    botanicalName: botanicalNames(sequelize),
    supplyLine: supplyLine(sequelize),
    volumePrice: volumePrices(sequelize),
    supplier: suppliers(sequelize),
    sequenceNumber: sequenceNumber(sequelize),
    connection: connections(sequelize),
};

/* Remove ID atribute from models */
models.characteristic.removeAttribute('id');
models.seasonalPeriod.removeAttribute('id');
models.package.removeAttribute('id');
models.botanicalName.removeAttribute('id');
models.countryOfOriginIsoCode.removeAttribute('id');
/* ------------------------------ */

models.characteristic.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.seasonalPeriod.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.photo.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.packingConfiguration.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.packingConfiguration.hasMany(models.package, {
    foreignKey: 'packingConfigurationFk',
    as: 'package_Fk',
    targetKey: 'packingConfigurationId',
});

models.package.belongsTo(models.packingConfiguration, {
    foreignKey: 'packingConfigurationFk',
    as: 'packingConfiguration_Fk',
    targetKey: 'packingConfigurationId',
});


models.botanicalName.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.countryOfOriginIsoCode.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.volumePrice.belongsTo(models.supplyLine, {
    foreignKey: 'supplyLineFk',
    as: 'supplyLine_Fk',
    targetKey: 'supplyLineId',
});

models.supplyLine.belongsTo(models.tradeItem, {
    foreignKey: 'tradeItemFk',
    as: 'tradeItem_Fk',
    targetKey: 'tradeItemId',
});

models.tradeItem.belongsTo(models.supplier, {
    foreignKey: 'supplierOrganizationId',
    as: 'supplierOrganization_Id',
    targetKey: 'organizationId',
});

if (process.env.FORCE_SYNC === 'true') {
    console.log('Forcing the models...');
    await sequelize.sync({ force: true });
} else {
    console.log('Altering the models...');
    await sequelize.sync({ alter: true });
}

if (process.env.SECRETS) {
    await models.clientConfig.findOrCreate({
        where: {
            id: 1,
        },
        defaults: {
            clientId: process.env.CLIENT_ID,
            clientSecret: process.env.CLIENT_SECRET,
        },
    });
}

/**
 * Creates the connection to the database.
 * 
 * @example
 * let sequelize = createConnection();
 * 
 * @returns {Sequelize} Sequelize instance with the connection to the database.
 */
function createConnection() {
    console.log('Creating the connection...');
    return new Sequelize(process.env.DB_SCHEMA, process.env.DB_USER, process.env.DB_PWD, {
        host: process.env.DB_HOST,
        dialect: process.env.DB_DIALECT,
        logging: false,
        pool: {
            max: 40,
            min: 0,
            acquire: 60000,
            idle: 10000,
        },
    });
}

export { models } ;