"""Simple GML & KML Loader wrapping ogr2ogr.
Usage:
    loader = Loader()
    loader.run(config)
For a full list of config see read_config"""

def __init__(self):
    pass

def run(self, config):
    self.read_config(config)
    self.setup()
    self.load()
    self.cleanup()

def read_config(self, config):
    self.config = config
    try:
        self.src_dir = config['src_dir']
        self.out_dir = config['out_dir']
        self.tmp_dir = config['tmp_dir']
        self.prep_cmd = config['prep_cmd']
        self.ogr_cmd = config['ogr_cmd']
        self.gfs_file = config['gfs_file']
    except KeyError as key:
        raise MissingConfigError(key)
    self.debug = config.get('debug')
    self.post_cmd = config.get('post_cmd')

def setup(self):
    # Determine if we are in debug mode
    self.debug = (str(self.debug).lower() == 'true')
    if self.debug:
        print("Config: %s" % self.config)
    # Set the encoding of the text output by the prep_cmd
    os.environ['PYTHONIOENCODING'] = 'utf-8'
    # Check that a valid gfs is file specified
    if not os.path.isfile(self.gfs_file):
        self.gfs_file = None
        print("No valid gfs file found, output schema and geometry types will be determined dynamically by OGR")
    # Create a temp directory as a child to the temp
    # directory specified to hold all of our working
    # files and to make cleaning up simple
    try:
        self.tmp_dir = tempfile.mkdtemp(dir=self.tmp_dir)
    except (OSError) as ex:
        raise CreateTempDirError(ex.errno, ex.strerror, self.tmp_dir)

def cleanup(self):
    if not self.debug:
        try:
            shutil.rmtree(self.tmp_dir)
        except OSError as ex:
            raise RemoveTempDirError(ex.errno, ex.strerror, self.tmp_dir)

def load(self):
    # Create string templates for the commands
    self.ogr_cmd = Template(self.ogr_cmd)
    num_files = 0
    if os.path.isdir(self.src_dir):
        for root, dirs, files in os.walk(self.src_dir):
            for file_name in files:
                ext = os.path.splitext(file_name)[1].lower()
                if ext in ['.gz', '.gml', '.zip', '.kml']:
                    if self.load_file(root, file_name):
                        num_files += 1
    else:
        (root, file_name) = os.path.split(self.src_dir)
        if self.load_file(root, file_name):
            num_files += 1
    print("Loaded %i file%s" % (num_files, "" if num_files == 1 else "s"))

def load_file(self, root, file_name):
    exit_status = 0

    file_path = os.path.join(root, file_name)
    print("Processing: %s" % file_path)

    # Run the script to prepare the GML if one is defined, otherwise just
    # copy the existing file to the tmp directory
    prep_file_name = os.path.splitext(file_name)[0]
    prep_file_path = os.path.join(self.tmp_dir, prep_file_name)
    if self.debug:
        print("Prepared file: %s" % prep_file_path)
    if self.prep_cmd:
        prep_args = shlex.split(Template(self.prep_cmd).safe_substitute(file_path='\'' + file_path + '\''))
        if self.debug:
            print("Prep command: %s" % " ".join(prep_args))
        with open(prep_file_path, 'w') as f:
            exit_status = subprocess.call(prep_args, stdout=f, stderr=sys.stderr)
            if exit_status != 0:
                return False
    else:
        shutil.copy(file_path, prep_file_path)

    # Copy over the template gfs file used by ogr2ogr
    # to read the GML attributes, determine the geometry type etc.
    # Using a template so we have control over the geometry type
    # for each table
    if self.gfs_file:
        shutil.copy(self.gfs_file, os.path.join(self.tmp_dir, prep_file_name + '.gfs'))

    # Run ogr2ogr to do the actual load
    print("Loading: %s" % file_path)
    ogr_args = shlex.split(self.ogr_cmd.safe_substitute(out_dir='\'' + self.out_dir + '\'', output_dir='\'' + self.out_dir + '\'', base_file_name='\'' + prep_file_name + '\'', file_path='\'' + prep_file_path + '\'', gfs_file='\'' + self.gfs_file + '\''))
    if self.debug:
        print("OGR command: %s" % " ".join(ogr_args))
    exit_status = subprocess.call(ogr_args, stderr=sys.stderr)
    if exit_status != 0:
        return False

    # If there is a post command defined then run it,
    # commonly used to do some post processing of the
    # output created by ogr2ogr
    if self.post_cmd:
        post_cmd = Template(self.post_cmd)
        post_args = shlex.split(post_cmd.safe_substitute(out_dir='\'' + self.out_dir + '\'', output_dir='\'' + self.out_dir + '\'', base_file_name='\'' + prep_file_name + '\'', file_path='\'' + prep_file_path + '\''))
        if self.debug:
            print("Post command: %s" % " ".join(post_args))
        exit_status = subprocess.call(post_args, stderr=sys.stderr)
        if exit_status != 0:
            return False
    if not self.debug:
        # Clean up by deleting the temporary prepared file
        os.remove(prep_file_path)

    return True