const mongoose = require('mongoose').set('debug', false)
const Schema = mongoose.Schema;

const tools = require('../tools/general');
const { ObjectId } = require('mongodb');

const { IImg } = require('../models/myscheda');

mongoose.Promise = global.Promise;
mongoose.level = "F";


// Resolving error Unknown modifier: $pushAll
mongoose.plugin(schema => {
  schema.options.usePushEach = true
});


const CatalogSchema = new Schema({
  idapp: {
    type: String,
  },
  active: {
    type: Boolean,
    default: false,
  },
  title: {
    type: String,
  },
  foto_collana: IImg,
  
  idCollane: [{
    type: String,
  }],
  idTipoFormato: [{
    type: Number,
  }],
  
  argomenti: [{
    type: String,
  }],
  condition_andor: {
    type: Number,
    default: 0,
  },
  
  editore: [{ type: String }],
  
  descr_introduttiva: {
    type: String,
  },
  idPageAssigned: {
    type: String,
  },
  idPageAssigned_stampa: {
    type: String,
  },
  referenti: [{
    type: String,
  }],

  img_bordata: IImg,
  img_intro: IImg,
  img_bordata_stampa: IImg,
  img_intro_stampa: IImg,
  pagina_introduttiva_sfondo_nero: {
    type: Boolean,
  },

  pdf_generato: String,
  data_generato: {
    type: Date,
  },
  pdf_online: String,
  data_online: {
    type: Date,
  },

  date_created: {
    type: Date,
    default: Date.now
  },
  date_updated: {
    type: Date,
  },
  lista_prodotti: [{
    type: Schema.Types.ObjectId,
    ref: 'Product',
  }],
});

/* 
TOLTO ALTRIMENTI su /settable non mi crea l'ID
CatalogSchema.pre('save', async function (next) {
  if (this.isNew) {
    this._id = new ObjectId();
  }

  next();
});
*/

CatalogSchema.statics.getFieldsForSearch = function () {
  return [{ field: 'title', type: tools.FieldType.string }]
};

CatalogSchema.statics.executeQueryTable = function (idapp, params, user) {
  params.fieldsearch = this.getFieldsForSearch();
  return tools.executeQueryTable(this, idapp, params, user);
};

/*CatalogSchema.statics.OLD_findAllIdApp = async function (idapp) {
  const Catalog = this;

  const arrrec = await Catalog.aggregate([
    // Filtra i documenti per idapp
    { $match: { idapp } },

    // Ordina i risultati per titolo
    { $sort: { title: 1 } },

    // Esegui il join con la collezione Collana
    {
      $lookup: {
        from: "collanas", // Nome della collezione Collana
        localField: "idCollane", // Campo in Catalog
        foreignField: "idCollana", // Campo in Collana
        as: "collana_info" // Nome del campo che conterrà i risultati del join
      }
    },

  ]);

  return arrrec;
};*/

CatalogSchema.statics.findAllIdApp = async function (idapp) {
  const Catalog = this;

  let arrrec = await Catalog.find({ idapp })
    .sort({ title: 1 }) // Ordina i risultati per titolo
    /*.populate({
      path: "idCollane", // Popola il campo idCollane
      model: "Collana" // Specifica il modello della collezione Collana
    })*/
    .populate({
      path: "lista_prodotti", // Popola il campo lista_prodotti
      populate: {
        path: "idProductInfo", 
        model: "ProductInfo", 
        populate: [
          {
            path: "idCatProds",
            model: "CatProd"
          },
          {
            path: "idSubCatProds",
            model: "SubCatProd"
          },
          {
            path: "idAuthors",
            model: "Author"
          }
        ],
      },
    })
    .populate({
      path: "lista_prodotti",
      populate: {
        path: "idProducer",
        model: "Producer"
      }
    })
    .populate({
      path: "lista_prodotti",
      populate: {
        path: "idProvider",
        model: "Provider"
      }
    })
    .populate({
      path: "lista_prodotti",
      populate: {
        path: "idStorehouses",
        model: "Storehouse"
      }
    })
    .populate({
      path: "lista_prodotti",
      populate: {
        path: "idScontisticas",
        model: "Scontistica"
      }
    })
    .populate({
      path: "lista_prodotti",
      populate: {
        path: "idGasordine",
        model: "Gasordine"
      }
    })
    ;

  const transformedArrRec = arrrec.map(catalog => ({
    ...catalog.toObject(), // Converte il documento Mongoose in un oggetto JavaScript puro
    lista_prodotti: catalog.lista_prodotti.map(product => ({
      ...product.toObject(),
      productInfo: {
        ...product.idProductInfo.toObject(), // Copia tutti i campi di idProductInfo
        catprods: product.idProductInfo.idCatProds, // Rinomina idCatProds in catprods
        subcatprods: product.idProductInfo.idSubCatProds,
        collana: product.idProductInfo.idCollana,
        authors: product.idProductInfo.idAuthors,
      },
      producer: product.idProducer,
      storehouse: product.idStorehouses,
      scontisticas: product.idScontisticas,
      gasordine: product.idGasordine,
    })),
  }));

  return transformedArrRec;
};

const Catalog = mongoose.model('Catalog', CatalogSchema);

Catalog.createIndexes()
  .then(() => { })
  .catch((err) => { throw err; });


module.exports = { Catalog };