from FiniteFieldMatrix import FiniteFieldMatrix
from FiniteField import FiniteFieldGF257
import os

str_to_byte = {}
for i in range(0,256):
    str_to_byte[chr(i)] = i

def asbyte(c):
    """ returns the integer byte equalvalent of a character """
    if len(c) > 1:
        raise TypeError("string must be of len 1")
    return str_to_byte[c]

class Joiner(object):
    """ This take a matrix and returns a string of all the characters in that
        matrix.  This converts matrix data into file data.
    """
    def __init__(self, m):
        self.m = m

    def __str__(self):
        retval = ''
        for r in range(0,self.m.rows()):
            retval += "".join([chr(x) for x in self.m.m[r] if x > 0])
        return retval
        
class FileJoiner(Joiner):
    """ This does the same thing as Joiner but stored the filename """
    def __init__(self, m, filename):
        self.filename = filename
        
    def write(self):
        pass
    
class FileSplitter(object):
    """ Given a file this class allows you to split the file into pieces """
    def __init__(self, filename, number_of_pieces):
        self.filename = filename
        self.number_of_pieces = number_of_pieces

    def matrix(self):
        """ Returns a matrix in GF(2^8) representing the file's data """
        dafile = file(self.filename)
        fsize = os.path.getsize(self.filename)
        step = fsize/self.number_of_pieces
        step += 1
        data_matrix = []
        for i in range(0, fsize, step):
            bytes = []
            number_read = 0
            for byte in dafile.read(step):
                number_read += 1
                bytes.append(asbyte(byte))
            if number_read < step:
                for j in range(0, step-number_read):
                    bytes.append(0);
            data_matrix.append(bytes)
        return FiniteFieldMatrix(data_matrix,
                                 class_type=FiniteFieldGF257)

import unittest
class TestFileSpliter(unittest.TestCase):
    def setUp(self):
        self.test_file = "/etc/hosts"

    def testFileSplit(self):
        number_to_split = 7
        fs = FileSplitter(self.test_file, number_to_split)
        M = fs.matrix()
        self.failUnless(M.rows() == number_to_split, "Number of matrix rows do not match the number_to_split (%d vs %d)" % (M.rows(),number_to_split))
        fj = Joiner(M)
        orig_file = file(self.test_file)
        orig_data = orig_file.read()
        self.failUnless(str(fj) == orig_data, "Data re-joined does not match test data file")

if __name__ == "__main__":
    unittest.main()