BanksProblemReview

// Generar código para crear un OBJETO que contenga los nombres de los bancos como KEY y los valores de éstas sean ARREGLOS con los ruts de sus clientes ordenados alfabéticamente por nombre

const banks = [
    { id: 1, name: 'Bank of America' },
    { id: 2, name: 'Citibank' },
    { id: 3, name: 'China Central Bank' },
  ];
  
  const clients = [
    { id: 1, taxNumber: '86620855', name: 'Bob Dylan' },
    { id: 2, taxNumber: '7317855K', name: 'John Meyer' },
    { id: 3, taxNumber: '73826497', name: 'Andrea Skileto' },
    { id: 4, taxNumber: '88587715', name: 'Maria Perez' },
    { id: 5, taxNumber: '94020190', name: 'Shania Twonk' },
    { id: 6, taxNumber: '99804238', name: 'Djork Wrek' }
  ];
  
  const accounts = [
    { clientId: 6, bankId: 1, balance: 15000 },
    { clientId: 1, bankId: 3, balance: 18000 },
    { clientId: 5, bankId: 3, balance: 135000 },
    { clientId: 2, bankId: 2, balance: 5600 },
    { clientId: 3, bankId: 1, balance: 23000 },
    { clientId: 5, bankId: 2, balance: 15000 },
    { clientId: 3, bankId: 3, balance: 45900 },
    { clientId: 2, bankId: 3, balance: 19000 },
    { clientId: 4, bankId: 3, balance: 51000 },
    { clientId: 5, bankId: 1, balance: 89000 },
    { clientId: 1, bankId: 2, balance: 1600 },
    { clientId: 5, bankId: 3, balance: 37500 },
    { clientId: 6, bankId: 1, balance: 19200 },
    { clientId: 2, bankId: 3, balance: 10000 },
    { clientId: 3, bankId: 2, balance: 5400 },
    { clientId: 3, bankId: 1, balance: 9000 },
    { clientId: 4, bankId: 3, balance: 13500 },
    { clientId: 2, bankId: 1, balance: 38200 },
    { clientId: 5, bankId: 2, balance: 17000 },
    { clientId: 1, bankId: 3, balance: 1000 },
    { clientId: 5, bankId: 2, balance: 600 },
    { clientId: 6, bankId: 1, balance: 16200 },
    { clientId: 2, bankId: 2, balance: 10000 }
  ];
  
  function populateAccounts(accounts){
      let populatedAccounts = [];
      accounts.map(account => {
          let accountObj = {
            //  Siempre se debe tener en cuenta el performance de una aplicación 
            // En este ejemplo estás recorriendo dos veces el array de clientes y uno el de banco para cada iteración
            // Supon que clientes sea un array muy grande y el client lo encuentres en el lugar 100 y bancos lo encuentres en el 100
            // recorres 300 elementos por iteración, si estamos iterando 100 cuentas tendrás 30,000 iteraciones 
              clientName: clients.find( client => client.id === account.clientId).name,
            //   Debería traer el taxNumber pero en cambio le cambias el nombre a la propiedad lo que podría tener errores
              clientTaxNumber: clients.find( client => client.id === account.clientId).taxNumber,
              bank: banks.find( bank => bank.id === account.bankId),
              // balance: account.balance
          }    
        //   El map de arriba crea un array nuevo desde cero, estás perdiendo esa funcionalidad haciendo un push de tus 100 objetos
        //  en cambio podrías retornar  el accounts.map
          populatedAccounts.push(accountObj)
      })
      return populatedAccounts
  }
  
  function groupBanks(populatedAccounts){
      return populatedAccounts.reduce((acc, obj)=>{
        // Si sabes que siempre será bank y no es dinámico es mejor acceder así obj.bank.name
        // si tienes miedo porque estás anidando dos veces puedes hacer esto obj?.bank.name
          let key = obj['bank'].name
        //   La idea de usar find, reduce, map es no MUTAR el objeto, eliminando la propiedad bank estás mutando el objeto
        // este mismo delete ocasiona que cuando haga un console.log no pueda ver bien qué pasa con los bancos
          delete obj['bank']
        //   ---------------------------
          if (!acc[key]) { // Para checar las propiedades me gusta más usar acc.hasOwnProperty(key)
              acc[key] = []
          }            
          acc[key].push(obj)
        //   ---------------------------
        //   Puedes resumir lo anterior con un ternario
        // !!acc[key] ? acc[key].push(obj) : acc[key] = [];
          return acc    
      }, {})
  }
  
  function filterBankDuplicates(groupedBanks){
      let keys = Object.keys(groupedBanks) 
      let filteredBankDuplicates = {}    
      keys.forEach(element => {
        //   Cuando usas propiedades cómo filter lo mejor es usar variables semánticas o con significado
        //  usar v,i,a hace más difícil saber a qué se refiere
        // Volvemos a lo mismo del performance, si tienes 100 cuentas y adentro 100 rows estarías haciendo 10,000 operaciones por cada llave de los bancos
          let depuredBank = groupedBanks[element].filter((v,i,a)=>a.findIndex(t=>(t.clientTaxNumber === v.clientTaxNumber))===i)           
        //   Una forma de eliminar duplicados es usar un Set()
          filteredBankDuplicates[element] = depuredBank
      });
      return filteredBankDuplicates
  }
  
  function sortBankAccountsByName(filteredBankDuplicates){
      let keys = Object.keys(filteredBankDuplicates) 
      let sortedBankAccountsByName = {}
    //   En lugar de un for each podrías haber usado un reduce o un map
      keys.forEach(element => {
          let depuredBank = filteredBankDuplicates[element].sort((bankA, bankB)=>bankA.clientName < bankB.clientName ? -1 : 1)        
          sortedBankAccountsByName[element] = depuredBank
      });
      return sortedBankAccountsByName
  }
//   ----------------------------------------------------
let populatedAccounts = populateAccounts(accounts)
let groupedBanks = groupBanks(populatedAccounts)
let filteredBankDuplicates = filterBankDuplicates(groupedBanks)
let sortedBankAccountsByName = sortBankAccountsByName(filteredBankDuplicates)
//   ----------------------------------------------------
// Esto puede ser sustituido por esto (usamos el resultado de una función como argumento de otra)
let result = sortBankAccountsByName(filterBankDuplicates(groupBanks(populateAccounts(accounts))));
//   ----------------------------------------------------
  // console.log('populatedAccounts:' , populatedAccounts)
  // console.log('groupedBanks:' , groupedBanks)
  // console.log('filteredBankDuplicates:' , filteredBankDuplicates)
  // console.log('sortedBankAccountsByName:' , sortedBankAccountsByName)
  
  console.log('Result:' , populatedAccounts)