#format python

"""TravelingSalesmanProblem solving using GeneticAlgorithm by Sujin and destine
"""

import unittest

def encode(path):
    temp = range(1, len(path)+1)
    result = []
    for eachpath in path:
        p = temp.index(eachpath)
        result.append(p+1)
        temp.remove(eachpath)
    return result

    if path == [1]:
        return [1]
    elif path == [1,2]:
        return [1,1]

def decode(depath):
    temp = range(1, len(depath) +1)
    result = []
    for eachpath in depath:
        p = temp[eachpath - 1]
        result.append(p)
        temp.remove(p)
    return result 
def getDistance(path):
    distanceMap=[[ 0, 10, 20, 30, 40, 50], 
             [10,  0,  9, 40, 25, 15], 
             [20,  9,  0, 32,  9, 41], 
             [30, 40, 32,  0, 39,  5],  
             [40, 25,  9, 39,  0, 27], 
             [50, 15, 41,  5, 27,  0]]
    result = 0
    if len(path) == 1:
        return 0
    for eachpath in range(len(path)-1):
        result = result + distanceMap[path[eachpath]-1][path[eachpath+1]-1]  
    return result
def crossOver(path1, path2, xPoint):
    depath1 = encode(path1)
    depath2 = encode(path2)
    if len(depath1) != len(depath2):
        return 0
    # This swapping algorithm can be possible.
    #temp = []
    #childpath1 = depath1[:]
    #childpath2 = depath2[:]
    #if xPoint <= 0 or xPoint>= len(depath1):
    #    return 0
    #temp = childpath2[xPoint:]
    #childpath2[xPoint:] = childpath1[xPoint:]
    #childpath1[xPoint:] = temp
    
    # in Python this index slicing is more preferred.
    if xPoint <= 0 or xPoint>= len(depath1):
        return 0
    childpath1 = depath1[:xPoint] + depath2[xPoint:]
    childpath2 = depath2[:xPoint] + depath1[xPoint:]
    
    return decode(childpath1), decode(childpath2)
    
class TestEnDecoding(unittest.TestCase):
    def testEncoding1(self):
        path = [1]
        self.assertEquals([1], encode(path))
    def testEncoding2(self):
        path = [1,2]
        self.assertEquals([1,1], encode(path))
    def testEncoding3(self):
        path = [3, 4, 1, 2, 5]
        self.assertEquals([3,3,1,1,1], encode(path))
    def testDecoding1(self):
        depath = [1]
        self.assertEquals([1], decode(depath))
    def testDecoding2(self):
        depath = [1,3,2,2,2,1]
        self.assertEquals([1,4,3,5,6,2], decode(depath))
    def testGetDistance1(self):
        path = [1]
        self.assertEquals(0, getDistance(path))
    def testGetDistance2(self):
        path = [1, 2]
        self.assertEquals(10, getDistance(path))
    def testGetDistance3(self):
        path = [1,2,3]
        self.assertEquals(19, getDistance(path))
    def testCrossOver1(self):
        path1 = [1,2]
        path2 = [2,1]
        self.assertEquals(([1,2],[2,1]), crossOver(path1, path2, 1))
    def testCrossOver2(self):
        path1 = [1,2,3,4,5,6]
        path2 = [3,1,4,2,6,5]
        self.assertEquals(([1,2,3,4,6,5],[3,1,4,2,5,6]),  crossOver(path1, path2, 3))
        
if __name__ == '__main__':
    unittest.main()