#!/usr/bin/env python

SOURCE='source'
RESULT='result'

NAME='name'
SIZE='size'
COUNT='count'
TYPE='type'
MULTIPLIER='multiplier'

# chunks sizes
SAME='same'
ALIGNED_INCREASE='aligned_increase'
ALIGNED_DECREASE='aligned_decrease'
NOT_ALIGNED='not_aligned'
PARTIALLY_ALIGNED='partially_aligned'

CHUNK_SIZES_LIST=[SAME, ALIGNED_INCREASE, ALIGNED_DECREASE, NOT_ALIGNED, PARTIALLY_ALIGNED]

# overlap
OVERLAP_SAME='overlap_same'
OVERLAP_NONE='overlap_none'
OVERLAP_ADD='overlap_add'
OVERLAP_REMOVE='overlap_remove'
OVERLAP_INCREASE='overlap_increase'
OVERLAP_DECREASE='overlap_decrease'

OVERLAP_LIST=[OVERLAP_ADD, OVERLAP_REMOVE, OVERLAP_INCREASE, OVERLAP_DECREASE]

# algorithm
DENSE='dense'
SPARSE='sparse'

ALGORITHM_LIST=[DENSE, SPARSE]

SETTING_LIST= [CHUNK_SIZES_LIST, OVERLAP_LIST, ALGORITHM_LIST]
def include_setting(chunk_sizes, overlap, algorithm):
    return not ((chunk_sizes == SAME) and overlap in set([OVERLAP_SAME, OVERLAP_NONE]))
import itertools
PERMUTATIONS_LIST= itertools.ifilter(lambda setting: include_setting(*setting), itertools.product(*SETTING_LIST))

def print_setting(*setting):
    print "TEST [Chunk sizes: '%s' Overlap: '%s' Algorithm: '%s']" % tuple(setting)

import os

# defaults
prefix_path='testcases'
test=   os.path.join('t', 'checkin', 'other')
result= os.path.join('r', 'checkin', 'other')
data=   'data'
path_list= [ test, result, data ]
suffix_list= [ 'test', 'result', 'data' ]

prefix_name='tile_repart'

def getter(prefix, suffix):
    def result(*setting):
        return os.path.join('testcases', '%s_%s.%s' % (prefix, "_".join(setting), suffix))
    return result
GET_PATH_LIST= [ getter(prefix, suffix) for (prefix, suffix) in zip(path_list, suffix_list) ]

# setting

def get_overlap_setting(overlap):
    value=   1
    lesser=  value * 2
    greater= value * 3
    d= {
        OVERLAP_NONE:     { SOURCE: 0,       RESULT: 0       },
        OVERLAP_SAME:     { SOURCE: value,   RESULT: value   },
        OVERLAP_ADD:      { SOURCE: 0,       RESULT: value   },
        OVERLAP_REMOVE:   { SOURCE: value,   RESULT: 0       },
        OVERLAP_INCREASE: { SOURCE: lesser,  RESULT: greater },
        OVERLAP_DECREASE: { SOURCE: greater, RESULT: lesser  }
       }
    return d[overlap]

def get_chunk_setting(chunk_sizes):
    value=   2
    lesser=  value
    greater= value * 2
    coprime_first=  2
    coprime_second= 3
    d= {
        SAME:              { SIZE:  { SOURCE: value,            RESULT: value            },
                             COUNT: { SOURCE: value,            RESULT: value            } },
        ALIGNED_INCREASE:  { SIZE:  { SOURCE: lesser,           RESULT: greater          },
                             COUNT: { SOURCE: greater,          RESULT: lesser           } },
        ALIGNED_DECREASE:  { SIZE:  { SOURCE: greater,          RESULT: lesser           },
                             COUNT: { SOURCE: lesser,           RESULT: greater          } },
        NOT_ALIGNED:       { SIZE:  { SOURCE: coprime_first,    RESULT: coprime_second   },
                             COUNT: { SOURCE: coprime_second,   RESULT: coprime_first    } },
        PARTIALLY_ALIGNED: { SIZE:  { SOURCE: coprime_first*2,  RESULT: coprime_second*2 },
                             COUNT: { SOURCE: coprime_second*2, RESULT: coprime_first*2  } }
       }
    r= {}
    for key in d:
        value= d[key]
        r[key]= { SOURCE: { SIZE: value[SIZE][SOURCE], COUNT: value[COUNT][SOURCE] },
                  RESULT: { SIZE: value[SIZE][RESULT], COUNT: value[COUNT][RESULT] } }
    return r[chunk_sizes]

def dimension(chunk, overlap):
    def generate(setting):
        maximum= chunk[SIZE] * chunk[COUNT]
        size=    chunk[SIZE]
        multiply= lambda value: value * setting[MULTIPLIER]
        data= [maximum, size, overlap]
        data= tuple([ setting[NAME] ] + map(str, map(multiply, data)))
        return '%s=0:%s,%s,%s' % data
    return ','.join([ generate(setting) for setting in [ {NAME: 'x', MULTIPLIER: 1} ] ])

def attribute():
    def generate(attribute):
        return '%s: %s' % (attribute[NAME], attribute[TYPE])
    attribute= [ {NAME: 'a', TYPE: 'int32'} ]
    return ','.join(map(generate, attribute))

def generate_array(name, chunk, overlap):
    return 'create array %s [%s] <%s>' % (name, attribute(), dimension(chunk, overlap))

def remove_array(name):
    return 'remove(%s)' % name

def generate():
    for setting in PERMUTATIONS_LIST:
        print_setting(*setting)

        def data(*setting):
            return 'data'

        def test(chunk_sizes, overlap, algorithm):
            def setup():
                chunk_s= get_chunk_setting(chunk_sizes)
                overlap_s= get_overlap_setting(overlap)
                source= generate_array(SOURCE, chunk_s[SOURCE], overlap_s[SOURCE])
                result= generate_array(RESULT, chunk_s[RESULT], overlap_s[RESULT])
                return [source, result]
            def test():
                return ['scan(source)', 'repart(source, result)', 'store(repart(source, result), result)', 'scan(result)']
            def cleanup():
                return map(remove_array, [SOURCE, RESULT])
            header=  [ ['--' + header] for header    in ['setup', 'test', 'cleanup'] ]
            queries= [ [query + ';' for query in generator()] for generator in [setup, test, cleanup] ]
            lines= reduce(lambda result, line: result + line, [ header + queries for (header, queries) in zip(header, queries) ])
            return os.linesep.join(lines)

        def result(*setting):
            return 'result'

        def write_file(name, data):
            print "Write file: '%s'" % name
            f= open(name, 'w')
            f.write(data)
            f.close()
        ACTION_LIST= [test, result, data]
        [ write_file(get_path(*setting), action(*setting)) for (get_path, action) in zip(GET_PATH_LIST, ACTION_LIST) ]

if __name__ == "__main__":
    generate()