#!/usr/bin/env python
# -*- coding: utf-8 -*-

__author__ = 'holger.knust'

import codecs
import csv
import datetime
import locale
import logging
import os
import shutil
import time

def parse_number(value):
    value_numeric = 0.0

    if value:
        try:
            value_us_fmt = value.replace(".", "").replace(",",".")
            value_numeric = float(value_us_fmt)
        except ValueError as ve:
            logging.error(ve)
            logging.error("could not convert " + value)

    return value_numeric

def read_ref(ref_file):
    header_read = False
    ref_dict = dict()

    with codecs.open(ref_file, "r", encoding='utf-8') as f:
        reader = csv.reader(f, delimiter=';')
        for row in reader:
            if header_read:
                sizes = row[0]
                splits = row[1]

                size_list = sizes.split(",")
                split_list = splits.split(",")

                if len(size_list) != len(split_list):
                    logging.warning("Number of splits {0} and sizes {1} do not match".format(splits, sizes))
                else:
                    split_perc_raw = [int(s) for s in splits.split(",")]

                    if sum(split_perc_raw) == 100:
                        split_perc = [x / 100.0 for x in split_perc_raw]
                        # Save the percentage list
                        ref_dict[sizes] = split_perc
                    else:
                        logging.warning("The splits {0} for sizes {1} do not add up to 100%".format(splits, sizes))

            else:
                header_read = True

    return ref_dict

def split_orders_by_sizes(in_file, out_file, ref_dict):
    header_read = False
    qty_index = -1
    sizes_index = -1

    with codecs.open(in_file, "r", encoding='iso-8859-1') as f, codecs.open(out_file, "w", encoding='utf-8') as of:
        reader = csv.reader(f, delimiter=';')
        writer = csv.writer(of, delimiter=';')

        total = 0.0
        for row in reader:
            if header_read:
                sizes = row[sizes_index]
                if sizes in ref_dict:
                    split_perc_list = ref_dict[sizes]
                    sizes_list = sizes.split(",")
                    total_qty = int(round(parse_number(row[qty_index]),0))
                    qty_remaining = total_qty
                    num_sizes_left = len(sizes_list)
                    for size, perc in zip(sizes_list, split_perc_list):
                        row_copy = row
                        num_sizes_left -= 1
                        qty = int(round(perc * total_qty,0))
                        if qty_remaining >= qty:
                            qty_remaining -= qty
                        else:
                            qty = qty_remaining
                            qty_remaining = 0
                        row_copy[sizes_index] = size

                        if num_sizes_left == 0 and qty_remaining > 0:
                            row_copy[qty_index] = qty + qty_remaining
                        else:
                            row_copy[qty_index] = qty

                        writer.writerow(row_copy)
                else:
                    row.append("not_in_ref")
                    writer.writerow(row)
            else:
                header_read = True

                if "Groesse" in row:
                    sizes_index = row.index("Groesse")

                if "Anzahl" in row:
                    qty_index = row.index("Anzahl")

                writer.writerow(row)



def process(data_root):
    path_in = os.path.join(data_root, "in")
    path_out = os.path.join(data_root, "out")
    path_proc = os.path.join(data_root, "processed")
    path_err = os.path.join(data_root, "error")
    path_log = os.path.join(data_root, "log")
    path_ref = os.path.join(data_root, "ref")

    log_file_name = time.strftime("%Y%m%d-%H%M%S") + '.log'
    log_file = os.path.join(path_log, log_file_name)
    logging.basicConfig(filename=log_file, level=logging.DEBUG)

    files = os.listdir(path_in)
    num_files = len(files)

    print("Found {0} files...".format(num_files))

    if num_files == 0:
        return

    ref_file = os.path.join(path_ref,"Groessenschluessel.csv")
    logging.debug("Reading ref keys from {0}...".format(ref_file))
    ref_dict = read_ref(ref_file)

    for f in files:
        in_file = os.path.join(path_in, f)
        out_file = os.path.join(path_out, f)
        proc_file = os.path.join(path_proc, f)
        err_file = os.path.join(path_err, f)

        logging.debug("Calculating inventory for {0}...".format(in_file))

        if os.path.isfile(in_file):
            try:
                print("Converting {0} to {1}...".format(in_file, out_file))
                split_orders_by_sizes(in_file, out_file, ref_dict)
                shutil.move(in_file, proc_file)
            except Exception as e:
                logging.error(e)

                try:
                    shutil.move(in_file, err_file)
                    os.remove(out_file)
                except Exception as e:
                    logging.error(e)

def main():
    # data_root = r"/home/holger/git/thelen/data/"
    data_root = r"/ftproot/"
    # data_root = r"c:/temp/thelen/"

    project_data_root = os.path.join(data_root, "Matching_Vendor_Groessenschluessel")

    process(project_data_root)

    print("Done.")


if __name__ == "__main__":
    main()