#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
# name : update.py
# Copyright 2019 last scene
# Created: <2019-09-30>
# Distributed under terms of the MIT license.


import sys
import os
import time
import datetime
import subprocess
import platform
import shutil


'''

performs one-way update processing between specific directories based on file existence , update date and time.

'''

#無視したいファイルの一部文字列
ignore_list = [
'/.git',
'/ref',
'/_',
'.code-workspace',
'.aep',
'/old',
'.pyc',
'/Adobe',
'.gitignore',
'_tmp'
]


def update(source_path, target_path, overwrite=True, new=True, delete=True, **kwargs):
    test = kwargs.setdefault('test', False)

    def _update(source_path, target_path, overwrite=True, new=True, delete=True, **kwargs):
        #dir
        s_top_dir_name, t_top_dir_name = _get_root(source_path, target_path)

        ret_dir_dict = {}
        for p in [source_path, target_path]:
            ret = {}
            for _dir in find_all_dirs(p):
                d  = os.stat(_dir)
                dt = datetime.datetime.fromtimestamp(d.st_mtime)
                ret[_dir] = dt
            ret_dir_dict[p] = ret

        sdk_set = []
        tdk_set = []
        for sk in ret_dir_dict[source_path].keys():
            rel_sk = sk.split(os.sep + s_top_dir_name + os.sep)[-1]
            rel_sk = os.sep + rel_sk
            sdk_set.append(rel_sk)
        for tk in ret_dir_dict[target_path].keys():
            rel_tk = tk.split(os.sep + t_top_dir_name + os.sep)[-1]
            rel_tk = os.sep + rel_tk
            tdk_set.append(rel_tk)

        #file
        ret_dict = {}
        for p in [source_path, target_path]:
            ret = {}
            for file in find_all_files(p):
                f  = os.stat(file)
                dt = datetime.datetime.fromtimestamp(f.st_mtime)
                ret[file] = dt
            ret_dict[p] = ret

        sk_set = []
        tk_set = []
        for sk in ret_dict[source_path].keys():
            rel_sk = sk.split(os.sep + s_top_dir_name + os.sep)[-1]
            rel_sk = os.sep + rel_sk
            sk_set.append(rel_sk)
        for tk in ret_dict[target_path].keys():
            rel_tk = tk.split(os.sep + t_top_dir_name + os.sep)[-1]
            rel_tk = os.sep + rel_tk
            tk_set.append(rel_tk)

        return sk_set, tk_set, sdk_set, tdk_set, ret_dir_dict, ret_dict

    def _overwrite(ret_dict, sk_set, tk_set):
        file_overwrite_update_dict = {}
        same = set(sk_set) & set(tk_set)

        for sm in same:
            f_src_path = source_path + sm
            f_tar_path = target_path + sm

            if os.path.exists(f_src_path) and os.path.exists(f_tar_path):
                if ret_dict[source_path][f_src_path] > ret_dict[target_path][f_tar_path]:
                    file_overwrite_update_dict[f_src_path] = f_tar_path
        return file_overwrite_update_dict

    def _new(sk_set, tk_set, sdk_set, tdk_set):
        dir_new_update_list  = []
        file_new_update_dict = {}
        new_dir = set(sdk_set) - set(tdk_set)
        new_diff = set(sk_set) - set(tk_set)
        for nd in new_dir:
            d_tar_path = target_path + nd
            dir_new_update_list.append(d_tar_path)
        for dif in new_diff:
            f_src_path = source_path + dif
            f_tar_path = target_path + dif
            file_new_update_dict[f_src_path] = f_tar_path

        return dir_new_update_list, file_new_update_dict

    def _delete(sk_set, tk_set, sdk_set, tdk_set):
        dir_del_update_list  = []
        file_del_update_list = []
        del_dir_diff = set(tdk_set) - set(sdk_set)
        del_diff = set(tk_set) - set(sk_set)
        for dif in del_dir_diff:
            d_tar_path = target_path + dif
            dir_del_update_list.append(d_tar_path)
        for dif in del_diff:
            f_tar_path = target_path + dif
            file_del_update_list.append(f_tar_path)

        return dir_del_update_list, file_del_update_list

    def _get_root(source_path, target_path):
        s_top_dir_name = source_path.split(os.sep)[-1]
        t_top_dir_name = target_path.split(os.sep)[-1]
        if s_top_dir_name == os.sep:
            s_top_dir_name = source_path.split(os.sep)[-2]
        if t_top_dir_name == os.sep:
            t_top_dir_name = target_path.split(os.sep)[-2]
        return s_top_dir_name, t_top_dir_name

    sk_set, tk_set, sdk_set, tdk_set, ret_dir_dict, ret_dict = _update(source_path,
                                                                       target_path,
                                                                       overwrite=overwrite,
                                                                       new=new,
                                                                       delete=delete
                                                                       )

    if overwrite:
        file_overwrite_update_dict                = _overwrite(ret_dict, sk_set, tk_set)
    if new:
        dir_new_update_list, file_new_update_dict = _new(sk_set, tk_set, sdk_set, tdk_set)
    if delete:
        dir_del_update_list, file_del_update_list = _delete(sk_set, tk_set, sdk_set, tdk_set)

    if not test:
        if overwrite:
            for src, dist in file_overwrite_update_dict.items():
                shutil.copy(src, dist)
                print('# Overwrite copy newer file : {} -> {}'.format(src, dist))

        if new:
            dir_new_update_list.sort(key=len)
            for dist in dir_new_update_list:
                if not os.path.exists(dist):
                    os.mkdir(dist)
                    print('# Make the same directory : {}'.format(dist))
            for src, dist in file_new_update_dict.items():
                shutil.copy(src, dist)
                print('# Make new files : {} -> {}'.format(src, dist))

        if delete:
            for del_tar in file_del_update_list:
                os.remove(del_tar)
                print('# Delete files : {}'.format(del_tar))
            dir_del_update_list.sorted(key=len)
            for del_tar in dir_del_update_list:
                shutil.rmtree(del_tar)
                print('# Delete directory : {}'.format(del_tar))

    else:
        print('#### TEST mode ###')
        if overwrite:
            for src, dist in file_overwrite_update_dict.items():
                print('# Overwrite copy newer file : {} -> {}'.format(src, dist))

        if new:
            dir_new_update_list.sort(key=len)
            for dist in dir_new_update_list:
                if not os.path.exists(dist):
                    print('# Make the same directory : {}'.format(dist))
            for src, dist in file_new_update_dict.items():
                print('# Make new files : {} -> {}'.format(src, dist))

        if delete:
            for del_tar in file_del_update_list:
                print('# Delete files : {}'.format(del_tar))
            for del_tar in dir_del_update_list:
                print('# Delete directory : {}'.format(del_tar))

    print('# Done.')


def find_all_files(directory, ignores=ignore_list):
    for root, dirs, files in os.walk(directory):
        for file in files:
            p = os.path.join(root, file)
            ignore = False
            for ig in ignores:
                if ig in p:
                    ignore = True
                    break
            if not ignore:
                yield p


def find_all_dirs(directory, ignores=ignore_list):
    for root, dirs, _ in os.walk(directory):
        for _dir in dirs:
            p = os.path.join(root, _dir)
            ignore = False
            for ig in ignores:
                if ig in p:
                    ignore = True
                    break
            if not ignore:
                yield p


if __name__ == "__main__":
    source_path = sys.argv[1]
    target_path = sys.argv[2]
    update(source_path, target_path, overwrite=True, new=True, delete=True)