"""Splitters which split in a manner previously done, for oligo reordering.

These are useful for reorder and testing purposes (when things need to remain
identical between rounds of testing).
"""
import os
import csv
import re

from SynBio.OligoDatabase.Database import AssemblyDb
from SynBio.OligoSequences.OligoRegion import FixedEndOligo

class PamOligoReorderSplitter:
    """Split into oligos for MutS segments previously designed via PAM.

    This uses a previous splitting pattern to perform the splits here.
    """
    def __init__(self, assembly_props, pre_builder, post_builder,
                 base_file = None, id_file = None):
        self._assembly_props = assembly_props
        self._pre_builder = pre_builder
        self._post_builder = post_builder
        self._db_col = None
        if id_file:
            self._id_map = self._parse_id_file(base_file, id_file)

        name_re = '.*(?P<number>\d\d)$'
        self._name_pat = re.compile(name_re)

    def _parse_id_file(self, base_file, id_file):
        base_dir, junk = os.path.split(base_file)
        handle = open(os.path.join(base_dir, id_file))
        reader = csv.reader(handle)
        id_map = {}
        for name, design_id in reader:
            id_map[name] = int(design_id)
        handle.close()
        return id_map

    def copy(self):
        new_splitter = PamOligoReorderSplitter(self._assembly_props,
                                              self._pre_builder,
                                              self._post_builder)
        new_splitter._id_map = self._id_map
        new_splitter._db_col = self._db_col
        return new_splitter
    
    def set_melt_calc(self, melt_calc):
        pass

    def provide_db_info(self, db_col):
        self._db_col = db_col

    def split(self, name, seq, ref_start, ref_end, index_pos, num_pieces,
            previous_vectors, db_col):
        """Split the given sequence using our various approaches.
        """
        old_id = self._id_map[name]
        old_assembly = AssemblyDb(self._db_col.design_db, self._db_col.track_db,
                                  old_id)
        old_seq = old_assembly.get_seq_by_parent()
        assert old_seq == seq
        parts = []
        for old_sub in old_assembly.get_subassemblies():
            start, end = old_sub.get_coords()
            old_name = old_sub.get_name()
            match = self._name_pat.match(old_name)
            assert match is not None, old_name
            number = match.group('number')
            part_name = '%s-%s' % (name, number)
            new_part = FixedEndOligo(part_name, seq, start, end,
                                     self._assembly_props, None, 0,
                                     five_fixed = True, three_fixed = True)
            print 'Reorder', part_name, start, end
            parts.append(new_part)
        pre_builder = self._pre_builder.copy()
        post_builder = self._post_builder.copy()
        return parts, post_builder, pre_builder