package com.tapina.robe.runtime;
   
   import com.tapina.robe.module.RelocatableModuleArea;
   import com.tapina.robe.module.Module;
   
   import java.util.Iterator;
   import java.util.Arrays;
   
   /***
   * This class encapsulates the logic for finding blocks of data in the memory map.
   * It has been placed in a separate class as otherwise it makes a very long unwieldy method.
   */
  class BlockLocator {
      final int address, length;
      final boolean allowExtend;
      final boolean allowCreate;
      final Iterator iterator;
  
      DataBlock blockBefore = null, blockAfter = null;
      private MemoryMap memoryMap;
  
      BlockLocator(MemoryMap memoryMap, int address, int length) {
          this.memoryMap = memoryMap;
          this.address = address;
          this.length = length;
          if (MemoryMap.isRomAddress(address)) {
              iterator = Arrays.asList(MemoryMap.romModules).iterator();
              allowExtend = allowCreate = false;
          } else if (RelocatableModuleArea.isRmaAddress(address)) {
              iterator = MemoryMap.rma.iterator();
              allowExtend = allowCreate = false;
          } else if (MemoryMap.isDynamicAreaAddress(address)) {
              iterator = MemoryMap.dynamicAreas.iterator();
              allowExtend = true;
              allowCreate = false;
          } else {
              iterator = memoryMap.dataMap.values().iterator();
              allowExtend = allowCreate = true;
          }
      }
  
      /*
      * There are 9 theoretical situations which can occur based on the:
      * Start address being either in the block before, block after, or inbetween. (3 options)
      * End address being either in the block before, block after, or inbetween. (3 options)
      * The start address can never be in the block after because we know from the above that its address is
      * greater than the start address. And the end address cannot be in the block before if the start address is
      * inbetween. So there are only 3*2-1 = 5  options:
      * 1) Start in block before, end in block before.
      * 2) Start in block before, end in block after.
      * 3) Start in block before, end inbetween blocks.
      * 4) Start inbetween, end inbetween.
      * 5) Start inbetween, end in block after.
      */
      DataBlock findDataBlock() {
          findBeforeAndAfter();
  
          if (blockBefore == null) {
              MemoryMap.log.severe("findBlock() failing for address &" + Integer.toHexString(address));
          }
          return pickBlock();
      }
  
      private DataBlock pickBlock() {
          final int blockBeforeStartAddress = blockBefore.getAddress();
          final int blockBeforeEndAddress = blockBeforeStartAddress + blockBefore.getSize();
          final int blockAfterStartAddress = blockAfter != null ? blockAfter.getAddress() : 0;
          final int blockWantedEndAddress = address + length;
          if (blockBeforeEndAddress >= blockWantedEndAddress) {
              // Wholly contained within block before (option 1)
              return blockBefore();
          } else if (blockBeforeEndAddress > address) {
              // Starts within block before, may need to extend it or join the two blocks (options 2 or 3)
              if (blockAfter != null && blockAfterStartAddress < blockWantedEndAddress) {
                  return joinBlocks(blockBeforeStartAddress, blockAfterStartAddress);
              } else {
                  // Ends inbetween the two blocks (option 3)
                  return extendBlockBefore(blockBeforeEndAddress);
              }
          } else if (blockAfter != null && blockAfterStartAddress < blockWantedEndAddress) {
              // Starts after the block before, but extends into the block after (option 5)
              return extendBlockAfter(blockAfterStartAddress);
          } else {
              // Is outside of both blocks, extend one (option 4)
              return extendClosestOrCreate(blockBeforeEndAddress, blockAfterStartAddress);
          }
      }
  
      private DataBlock extendClosestOrCreate(final int blockBeforeEndAddress, final int blockAfterAddress) {
          int blockBeforeExtension = (address + length) - blockBeforeEndAddress;
          int blockAfterExtension = blockAfterAddress - address;
  
          if (blockBefore instanceof RawDataBlock && (blockAfter == null || blockBeforeExtension < blockAfterExtension)) {
              return extendBlockBefore(blockBeforeEndAddress);
          } else if (blockAfter instanceof RawDataBlock) {
              return extendBlockAfter(blockAfterAddress);
          } else if (allowCreate) {
              return memoryMap.createDataBlock(address, length);
          } else {
             throw new AddressException(address);
         }
     }
 
     private DataBlock extendBlockAfter(final int blockAfterAddress) {
         if (allowExtend) {
             ((RawDataBlock) blockAfter).extendBackwards(blockAfterAddress - address);
             return blockAfter;
         } else {
             throw new AddressException(address);
         }
     }
 
     private DataBlock extendBlockBefore(final int blockBeforeEndAddress) {
         if (allowExtend) {
             ((RawDataBlock) blockBefore).extendForwards((address + length) - blockBeforeEndAddress);
             return blockBefore;
         } else {
             throw new AddressException(address);
         }
     }
 
     private DataBlock joinBlocks(final int blockBeforeAddress, final int blockAfterStart) {
         if (allowCreate) {
             // Ends within the block after, we need to join the two blocks (option 2)
             byte[] combinedData = new byte[blockAfterStart + blockAfter.getSize() - blockBeforeAddress];
             System.arraycopy(blockBefore.getBytes(), 0, combinedData, 0, blockBefore.getSize());
             System.arraycopy(blockAfter.getBytes(), 0, combinedData, blockAfterStart - blockBeforeAddress, blockAfter.getSize());
             RawDataBlock dataBlock = new RawDataBlock(blockBeforeAddress, combinedData);
             memoryMap.dataMap.put(new Integer(address), dataBlock);
             memoryMap.dataMap.remove(new Integer(blockAfterStart));
             return dataBlock;
         } else {
             throw new AddressException(address);
         }
     }
 
     private DataBlock blockBefore() {
         if (blockBefore instanceof Module) {
             MemoryMap.log.fine("Reading data from inside module");
         }
         return blockBefore;
     }
 
     private void findBeforeAndAfter() {
         while (iterator.hasNext()) {
             final DataBlock block = (DataBlock) iterator.next();
             if (block.getAddress() <= address) {
                 blockBefore = block;
             } else {
                 blockAfter = block;
                 break;
             }
         }
     }
 
 }