# Class for searching same clusters
#
# Written by k-fleak
#

require "#{ENV["HOME"]}/myRuby/parseClusterOutSort.rb"
require "getopts"

class IdentifyCluster
  
  attr_reader :nBody
  
  def initialize(coutOrig, coutSearch, oIndex)
    @inputOrig   = ParseClusterOutOrig.new(coutOrig)
    @inputSearch = ParseClusterOutSearch.new(coutSearch)
    @origIndex   = oIndex
    calcNBody
  end
  
  def start
    case @nBody
    when 1
      calcSamePoint
    when 2
      calcSamePair
    when 3
      setPairDataOrig
      setPairDataSearch
      setTriDataSearch
      distSetPair = getPairDistSetInTri(@origIndex)
      pairIndexSetSearch = getPairIndexSetSearch(distSetPair)
      @sameTri = getSameTri(pairIndexSetSearch)
    when 4
      setPairDataOrig
      setPairDataSearch
      setTriDataOrig
      setTriDataSearch
      setTetraDataSearch
      triIndexSet = @inputOrig.getTetraData[[@origIndex]][0]
      triIndexInTetra = getOrigTriIndexInTetra(triIndexSet)
      distSetPairArray = getPairDistSetInTriArray(triIndexInTetra)
      pairIndexSetSearchArray = getPairIndexSetSearchArray(distSetPairArray)
      sameTriArray = getSameTriArray(pairIndexSetSearchArray)
      @sameTetra = getSameTetra(sameTriArray)
    end
  end
  
  def getSameCluster
    case @nBody
    when 1
      return @samePoint
    when 2
      return @samePair
    when 3
      return @sameTri
    when 4
      return @sameTetra
    end
  end
  
  def printSameCluster
    case @nBody
    when 1
      printSamePoint
    when 2
      printSamePair
    when 3
      printSameTri
    when 4
      printSameTetra
    end
  end
  
  private
  
  def calcNBody
    if @origIndex == "0" then
      @nBody = 0
    elsif @inputOrig.getPointData[[@origIndex]] then
      @nBody = 1
    elsif @inputOrig.getPairData[[@origIndex]] then
      @nBody = 2
    elsif @inputOrig.getTriData[[@origIndex]] then
      @nBody = 3
    elsif @inputOrig.getTetraData[[@origIndex]] then
      @nBody = 4
    else
      p "Error: wrong cluster index"
      exit()
    end
  end
  
  def calcSamePoint
    @samePoint = @inputSearch.getPointData
  end
  
  def calcSamePair
    distOrig = @inputOrig.getPairData[[@origIndex]][0]
    @samePair = @inputSearch.getPairData[distOrig]
  end
  
  def printSamePoint
    @samePoint.each do |sm|
      p sm
    end
  end
  
  def printSamePair
    @samePair.each do |cluster|
      p cluster
    end
  end
  
  def setPairDataOrig
    @pairDataOrig = @inputOrig.getPairData
  end
  
  def setPairDataSearch
    @pairDataSearch = @inputSearch.getPairData
  end
  
  def setTriDataOrig
    @triDataOrig = @inputOrig.getTriData
  end
  
  def setTriDataSearch
    @triDataSearch = @inputSearch.getTriData
  end
  
  def setTetraDataSearch
    @tetraDataSearch = @inputSearch.getTetraData
  end
  
  def getPairDistSetInTri(triIndex)
    distSet = Array.new()
    pairIndexSet = @inputOrig.getTriData[[triIndex]][0]
    pairIndexSet.each do |pairIndex|
      @pairDataOrig.each do |pair|
        if pair[1][2][0] == pairIndex then
          distSet.push(pair[1][0][0])
        end
      end
    end
    return distSet
  end
  
  def getPairDistSetInTriArray(triIndexInTetra)
    ptmp = Array.new
    triIndexInTetra.each do |tri|
      distSet = getPairDistSetInTri(tri)
      ptmp.push(distSet)
    end
    return ptmp
  end
      
      
      
  def getPairIndexSetSearch(distSet)
    pairIndexSet = Array.new
    distSet.each do |dist|
      ptmp = Array.new()
      @pairDataSearch[[dist]].each do |pD|
        ptmp.push(pD[1])
        ptmp.flatten!
      end
      pairIndexSet.push(ptmp)
    end
    return pairIndexSet
  end
  
  def getPairIndexSetSearchArray(distSetArray)
    ptmp = Array.new()
    distSetArray.each do |distSet|
      pset = getPairIndexSetSearch(distSet)
      ptmp.push(pset)
    end
    return ptmp
  end
  
  def getSameTri(pairIndexSetSearch)
    sameTri = Array.new()
    pairIndexSetSearch[0].each do |pair1|
      pairIndexSetSearch[1].each do |pair2|
        pairIndexSetSearch[2].each do |pair3|
          ptmp = [pair1.to_i, pair2.to_i, pair3.to_i]
          ptmp.sort!
          ptmp2 = [ptmp[0].to_s, ptmp[1].to_s, ptmp[2].to_s]
          #p ptmp2
          if @triDataSearch[ptmp2] then
            sameTri.push(@triDataSearch[ptmp2])
          end
        end
      end
    end
    sameTri.uniq!
    return sameTri
  end
  
  def getSameTetra(sameTriArray)
    sameTetra = Array.new()
    sameTriArray[0].each do |tri1|
      sameTriArray[1].each do |tri2|
        sameTriArray[2].each do |tri3|
          sameTriArray[3].each do |tri4|
            ptmp = [tri1.to_i, tri2.to_i, tri3.to_i, tri4.to_i]
            ptmp.sort!
            ptmp2 = [ptmp[0].to_s, ptmp[1].to_s, ptmp[2].to_s, ptmp[3].to_s]
            if @tetraDataSearch[ptmp2] then
              sameTetra.push(@tetraDataSearch[ptmp2])
            end
          end
        end
      end
    end
    sameTetra.uniq!
    return sameTetra
  end
  
  def printSameTetra
    @sameTetra.each do |tetra|
      p tetra
    end
  end
    
    
  def getSameTriArray(pairIndexSetSearchArray)
    ptmp = Array.new()
    pairIndexSetSearchArray.each do |pairIndexSetSearch|
      sameTri = getSameTri(pairIndexSetSearch)
      ptmp2 = Array.new()
      sameTri.each do |tri|
        ptmp2.push(tri[1][0])
      end
      ptmp.push(ptmp2)
    end
    return ptmp
  end
  
  def printSameTri
    @sameTri.each do |tri|
      p tri
    end
  end
  
  def getOrigTriIndexInTetra(triIndexIn)
    ptmp = Array.new()
    triIndexIn.each do |tri|
      @triDataOrig.each do |triOrig|
        if triOrig[1][2][0] == tri then
          ptmp.push(triOrig[0][0])
        end
      end
    end
    return ptmp
  end
  
end

#unless getopts("a", "i")
#  $stderr.puts("#{ARGV.shift}: illegal option\n")
#  exit
#end


#ids = IdentifyCluster.new()
#ids.start()

# option
# -a:  print all information
# -i:  print cluster index 


#case
#when $OPT_a
#  unless ids.nBody == 0 then
#    ids.printSameCluster
#  end
#when $OPT_i
#  unless ids.nBody == 0 then
#    sameCluster = ids.getSameCluster
#  end
#  case ids.nBody
#  when 0
#    print "0"
#  when 1
#    sameCluster.each do |sc|
#      print sc[1][1]
#      print "  "
#    end
#  else
#    sameCluster.each do |sc|
#      print sc[sc.size - 1]
#      print "  "
#    end
#  end
#  print "\n"
#end