/**
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.hadoop.hbase.master.balancer;
  
  import static org.junit.Assert.assertNotNull;
  import static org.junit.Assert.assertNull;
  import static org.junit.Assert.assertTrue;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Queue;
  import java.util.Random;
  import java.util.Set;
  import java.util.SortedSet;
  import java.util.TreeMap;
  import java.util.TreeSet;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.hadoop.conf.Configuration;
  import org.apache.hadoop.hbase.HBaseConfiguration;
  import org.apache.hadoop.hbase.HRegionInfo;
  import org.apache.hadoop.hbase.ServerName;
  import org.apache.hadoop.hbase.TableName;
  import org.apache.hadoop.hbase.client.RegionReplicaUtil;
  import org.apache.hadoop.hbase.master.RackManager;
  import org.apache.hadoop.hbase.master.RegionPlan;
  import org.apache.hadoop.hbase.util.Bytes;
  import org.apache.hadoop.net.DNSToSwitchMapping;
  import org.junit.Assert;
  import org.junit.BeforeClass;
  
  /**
   * Class used to be the base of unit tests on load balancers. It gives helper
   * methods to create maps of {@link ServerName} to lists of {@link HRegionInfo}
   * and to check list of region plans.
   *
   */
  public class BalancerTestBase {
    private static final Log LOG = LogFactory.getLog(BalancerTestBase.class);
    protected static Random rand = new Random();
    static int regionId = 0;
    protected static Configuration conf;
    protected static StochasticLoadBalancer loadBalancer;
  
    @BeforeClass
    public static void beforeAllTests() throws Exception {
      conf = HBaseConfiguration.create();
      conf.setClass("hbase.util.ip.to.rack.determiner", MockMapping.class, DNSToSwitchMapping.class);
      conf.setFloat("hbase.master.balancer.stochastic.maxMovePercent", 0.75f);
      conf.setFloat("hbase.regions.slop", 0.0f);
      conf.setFloat("hbase.master.balancer.stochastic.localityCost", 0);
      loadBalancer = new StochasticLoadBalancer();
      loadBalancer.setConf(conf);
    }
  
    protected int[] largeCluster = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56 };
  
    // int[testnum][servernumber] -> numregions
    protected int[][] clusterStateMocks = new int[][]{
        // 1 node
        new int[]{0},
        new int[]{1},
        new int[]{10},
        // 2 node
        new int[]{0, 0},
       new int[]{2, 0},
       new int[]{2, 1},
       new int[]{2, 2},
       new int[]{2, 3},
       new int[]{2, 4},
       new int[]{1, 1},
       new int[]{0, 1},
       new int[]{10, 1},
       new int[]{514, 1432},
       new int[]{48, 53},
       // 3 node
       new int[]{0, 1, 2},
       new int[]{1, 2, 3},
       new int[]{0, 2, 2},
       new int[]{0, 3, 0},
       new int[]{0, 4, 0},
       new int[]{20, 20, 0},
       // 4 node
       new int[]{0, 1, 2, 3},
       new int[]{4, 0, 0, 0},
       new int[]{5, 0, 0, 0},
       new int[]{6, 6, 0, 0},
       new int[]{6, 2, 0, 0},
       new int[]{6, 1, 0, 0},
       new int[]{6, 0, 0, 0},
       new int[]{4, 4, 4, 7},
       new int[]{4, 4, 4, 8},
       new int[]{0, 0, 0, 7},
       // 5 node
       new int[]{1, 1, 1, 1, 4},
       // 6 nodes
       new int[]{1500, 500, 500, 500, 10, 0},
       new int[]{1500, 500, 500, 500, 500, 0},
       // more nodes
       new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
       new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 10},
       new int[]{6, 6, 5, 6, 6, 6, 6, 6, 6, 1},
       new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 54},
       new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 55},
       new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 56},
       new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 16},
       new int[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 8},
       new int[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 9},
       new int[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 10},
       new int[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 123},
       new int[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 155},
       new int[]{10, 7, 12, 8, 11, 10, 9, 14},
       new int[]{13, 14, 6, 10, 10, 10, 8, 10},
       new int[]{130, 14, 60, 10, 100, 10, 80, 10},
       new int[]{130, 140, 60, 100, 100, 100, 80, 100},
       new int[]{0, 5 , 5, 5, 5},
       largeCluster,
 
   };
 
 
   // This class is introduced because IP to rack resolution can be lengthy.
   public static class MockMapping implements DNSToSwitchMapping {
     public MockMapping(Configuration conf) {
     }
 
     public List<String> resolve(List<String> names) {
       List<String> ret = new ArrayList<String>(names.size());
       for (String name : names) {
         ret.add("rack");
       }
       return ret;
     }
 
     // do not add @Override annotations here. It mighty break compilation with earlier Hadoops
     public void reloadCachedMappings() {
     }
 
     // do not add @Override annotations here. It mighty break compilation with earlier Hadoops
     public void reloadCachedMappings(List<String> arg0) {
     }
   }
 
   /**
    * Invariant is that all servers have between floor(avg) and ceiling(avg)
    * number of regions.
    */
   public void assertClusterAsBalanced(List<ServerAndLoad> servers) {
     int numServers = servers.size();
     int numRegions = 0;
     int maxRegions = 0;
     int minRegions = Integer.MAX_VALUE;
     for (ServerAndLoad server : servers) {
       int nr = server.getLoad();
       if (nr > maxRegions) {
         maxRegions = nr;
       }
       if (nr < minRegions) {
         minRegions = nr;
       }
       numRegions += nr;
     }
     if (maxRegions - minRegions < 2) {
       // less than 2 between max and min, can't balance
       return;
     }
     int min = numRegions / numServers;
     int max = numRegions % numServers == 0 ? min : min + 1;
 
     for (ServerAndLoad server : servers) {
       assertTrue("All servers should have a positive load. " + server, server.getLoad() >= 0);
       assertTrue("All servers should have load no more than " + max + ". " + server,
           server.getLoad() <= max);
       assertTrue("All servers should have load no less than " + min + ". " + server,
           server.getLoad() >= min);
     }
   }
 
   /**
    * Checks whether region replicas are not hosted on the same host.
    */
   public void assertRegionReplicaPlacement(Map<ServerName, List<HRegionInfo>> serverMap, RackManager rackManager) {
     TreeMap<String, Set<HRegionInfo>> regionsPerHost = new TreeMap<String, Set<HRegionInfo>>();
     TreeMap<String, Set<HRegionInfo>> regionsPerRack = new TreeMap<String, Set<HRegionInfo>>();
 
     for (Entry<ServerName, List<HRegionInfo>> entry : serverMap.entrySet()) {
       String hostname = entry.getKey().getHostname();
       Set<HRegionInfo> infos = regionsPerHost.get(hostname);
       if (infos == null) {
         infos = new HashSet<HRegionInfo>();
         regionsPerHost.put(hostname, infos);
       }
 
       for (HRegionInfo info : entry.getValue()) {
         HRegionInfo primaryInfo = RegionReplicaUtil.getRegionInfoForDefaultReplica(info);
         if (!infos.add(primaryInfo)) {
           Assert.fail("Two or more region replicas are hosted on the same host after balance");
         }
       }
     }
 
     if (rackManager == null) {
       return;
     }
 
     for (Entry<ServerName, List<HRegionInfo>> entry : serverMap.entrySet()) {
       String rack = rackManager.getRack(entry.getKey());
       Set<HRegionInfo> infos = regionsPerRack.get(rack);
       if (infos == null) {
         infos = new HashSet<HRegionInfo>();
         regionsPerRack.put(rack, infos);
       }
 
       for (HRegionInfo info : entry.getValue()) {
         HRegionInfo primaryInfo = RegionReplicaUtil.getRegionInfoForDefaultReplica(info);
         if (!infos.add(primaryInfo)) {
           Assert.fail("Two or more region replicas are hosted on the same rack after balance");
         }
       }
     }
   }
 
   protected String printStats(List<ServerAndLoad> servers) {
     int numServers = servers.size();
     int totalRegions = 0;
     for (ServerAndLoad server : servers) {
       totalRegions += server.getLoad();
     }
     float average = (float) totalRegions / numServers;
     int max = (int) Math.ceil(average);
     int min = (int) Math.floor(average);
     return "[srvr=" + numServers + " rgns=" + totalRegions + " avg=" + average + " max=" + max
         + " min=" + min + "]";
   }
 
   protected List<ServerAndLoad> convertToList(final Map<ServerName, List<HRegionInfo>> servers) {
     List<ServerAndLoad> list = new ArrayList<ServerAndLoad>(servers.size());
     for (Map.Entry<ServerName, List<HRegionInfo>> e : servers.entrySet()) {
       list.add(new ServerAndLoad(e.getKey(), e.getValue().size()));
     }
     return list;
   }
 
   protected String printMock(List<ServerAndLoad> balancedCluster) {
     SortedSet<ServerAndLoad> sorted = new TreeSet<ServerAndLoad>(balancedCluster);
     ServerAndLoad[] arr = sorted.toArray(new ServerAndLoad[sorted.size()]);
     StringBuilder sb = new StringBuilder(sorted.size() * 4 + 4);
     sb.append("{ ");
     for (int i = 0; i < arr.length; i++) {
       if (i != 0) {
         sb.append(" , ");
       }
       sb.append(arr[i].getServerName().getHostname());
       sb.append(":");
       sb.append(arr[i].getLoad());
     }
     sb.append(" }");
     return sb.toString();
   }
 
   /**
    * This assumes the RegionPlan HSI instances are the same ones in the map, so
    * actually no need to even pass in the map, but I think it's clearer.
    *
    * @param list
    * @param plans
    * @return a list of all added {@link ServerAndLoad} values.
    */
   protected List<ServerAndLoad> reconcile(List<ServerAndLoad> list,
                                           List<RegionPlan> plans,
                                           Map<ServerName, List<HRegionInfo>> servers) {
     List<ServerAndLoad> result = new ArrayList<ServerAndLoad>(list.size());
 
     Map<ServerName, ServerAndLoad> map = new HashMap<ServerName, ServerAndLoad>(list.size());
     for (ServerAndLoad sl : list) {
       map.put(sl.getServerName(), sl);
     }
     if (plans != null) {
       for (RegionPlan plan : plans) {
         ServerName source = plan.getSource();
 
         updateLoad(map, source, -1);
         ServerName destination = plan.getDestination();
         updateLoad(map, destination, +1);
 
         servers.get(source).remove(plan.getRegionInfo());
         servers.get(destination).add(plan.getRegionInfo());
       }
     }
     result.clear();
     result.addAll(map.values());
     return result;
   }
 
   protected void updateLoad(final Map<ServerName, ServerAndLoad> map,
                             final ServerName sn,
                             final int diff) {
     ServerAndLoad sal = map.get(sn);
     if (sal == null) sal = new ServerAndLoad(sn, 0);
     sal = new ServerAndLoad(sn, sal.getLoad() + diff);
     map.put(sn, sal);
   }
 
   protected TreeMap<ServerName, List<HRegionInfo>> mockClusterServers(int[] mockCluster) {
     return mockClusterServers(mockCluster, -1);
   }
 
   protected BaseLoadBalancer.Cluster mockCluster(int[] mockCluster) {
     return new BaseLoadBalancer.Cluster(
       mockClusterServers(mockCluster, -1), null, null, null);
   }
 
   protected TreeMap<ServerName, List<HRegionInfo>> mockClusterServers(int[] mockCluster, int numTables) {
     int numServers = mockCluster.length;
     TreeMap<ServerName, List<HRegionInfo>> servers = new TreeMap<ServerName, List<HRegionInfo>>();
     for (int i = 0; i < numServers; i++) {
       int numRegions = mockCluster[i];
       ServerAndLoad sal = randomServer(0);
       List<HRegionInfo> regions = randomRegions(numRegions, numTables);
       servers.put(sal.getServerName(), regions);
     }
     return servers;
   }
 
   private Queue<HRegionInfo> regionQueue = new LinkedList<HRegionInfo>();
 
   protected List<HRegionInfo> randomRegions(int numRegions) {
     return randomRegions(numRegions, -1);
   }
 
   protected List<HRegionInfo> randomRegions(int numRegions, int numTables) {
     List<HRegionInfo> regions = new ArrayList<HRegionInfo>(numRegions);
     byte[] start = new byte[16];
     byte[] end = new byte[16];
     rand.nextBytes(start);
     rand.nextBytes(end);
     for (int i = 0; i < numRegions; i++) {
       if (!regionQueue.isEmpty()) {
         regions.add(regionQueue.poll());
         continue;
       }
       Bytes.putInt(start, 0, numRegions << 1);
       Bytes.putInt(end, 0, (numRegions << 1) + 1);
       TableName tableName =
           TableName.valueOf("table" + (numTables > 0 ? rand.nextInt(numTables) : i));
       HRegionInfo hri = new HRegionInfo(tableName, start, end, false, regionId++);
       regions.add(hri);
     }
     return regions;
   }
 
   protected void returnRegions(List<HRegionInfo> regions) {
     regionQueue.addAll(regions);
   }
 
   private Queue<ServerName> serverQueue = new LinkedList<ServerName>();
 
   protected ServerAndLoad randomServer(final int numRegionsPerServer) {
     if (!this.serverQueue.isEmpty()) {
       ServerName sn = this.serverQueue.poll();
       return new ServerAndLoad(sn, numRegionsPerServer);
     }
     String host = "srv" + rand.nextInt(Integer.MAX_VALUE);
     int port = rand.nextInt(60000);
     long startCode = rand.nextLong();
     ServerName sn = ServerName.valueOf(host, port, startCode);
     return new ServerAndLoad(sn, numRegionsPerServer);
   }
 
   protected List<ServerAndLoad> randomServers(int numServers, int numRegionsPerServer) {
     List<ServerAndLoad> servers = new ArrayList<ServerAndLoad>(numServers);
     for (int i = 0; i < numServers; i++) {
       servers.add(randomServer(numRegionsPerServer));
     }
     return servers;
   }
 
   protected void returnServer(ServerName server) {
     serverQueue.add(server);
   }
 
   protected void returnServers(List<ServerName> servers) {
     this.serverQueue.addAll(servers);
   }
 
   protected void testWithCluster(int numNodes,
       int numRegions,
       int numRegionsPerServer,
       int replication,
       int numTables,
       boolean assertFullyBalanced, boolean assertFullyBalancedForReplicas) {
     Map<ServerName, List<HRegionInfo>> serverMap =
         createServerMap(numNodes, numRegions, numRegionsPerServer, replication, numTables);
     testWithCluster(serverMap, null, assertFullyBalanced, assertFullyBalancedForReplicas);
   }
 
   protected void testWithCluster(Map<ServerName, List<HRegionInfo>> serverMap,
       RackManager rackManager, boolean assertFullyBalanced, boolean assertFullyBalancedForReplicas) {
     List<ServerAndLoad> list = convertToList(serverMap);
     LOG.info("Mock Cluster : " + printMock(list) + " " + printStats(list));
 
     loadBalancer.setRackManager(rackManager);
     // Run the balancer.
     List<RegionPlan> plans = loadBalancer.balanceCluster(serverMap);
     assertNotNull("Initial cluster balance should produce plans.", plans);
 
     // Check to see that this actually got to a stable place.
     if (assertFullyBalanced || assertFullyBalancedForReplicas) {
       // Apply the plan to the mock cluster.
       List<ServerAndLoad> balancedCluster = reconcile(list, plans, serverMap);
 
       // Print out the cluster loads to make debugging easier.
       LOG.info("Mock Balance : " + printMock(balancedCluster));
 
       if (assertFullyBalanced) {
         assertClusterAsBalanced(balancedCluster);
         List<RegionPlan> secondPlans =  loadBalancer.balanceCluster(serverMap);
         assertNull("Given a requirement to be fully balanced, second attempt at plans should " +
             "produce none.", secondPlans);
       }
 
       if (assertFullyBalancedForReplicas) {
         assertRegionReplicaPlacement(serverMap, rackManager);
       }
     }
   }
 
   protected Map<ServerName, List<HRegionInfo>> createServerMap(int numNodes,
                                                              int numRegions,
                                                              int numRegionsPerServer,
                                                              int replication,
                                                              int numTables) {
     //construct a cluster of numNodes, having  a total of numRegions. Each RS will hold
     //numRegionsPerServer many regions except for the last one, which will host all the
     //remaining regions
     int[] cluster = new int[numNodes];
     for (int i =0; i < numNodes; i++) {
       cluster[i] = numRegionsPerServer;
     }
     cluster[cluster.length - 1] = numRegions - ((cluster.length - 1) * numRegionsPerServer);
     Map<ServerName, List<HRegionInfo>> clusterState = mockClusterServers(cluster, numTables);
     if (replication > 0) {
       // replicate the regions to the same servers
       for (List<HRegionInfo> regions : clusterState.values()) {
         int length = regions.size();
         for (int i = 0; i < length; i++) {
           for (int r = 1; r < replication ; r++) {
             regions.add(RegionReplicaUtil.getRegionInfoForReplica(regions.get(i), r));
           }
         }
       }
     }
 
     return clusterState;
   }
 
 }