import os.path as osp
import os
import argparse

import numpy as np
import numpy as np
import cv2
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from PIL import Image

import matplotlib.pyplot as plt
from vis_utils import *



if __name__ == '__main__':

    parser = argparse.ArgumentParser()
    parser.add_argument('--saved', type=str, default=None)
    parser.add_argument('--srcp', type=str)

    args = parser.parse_args()
    srcp = args.srcp
    saved = args.saved

    if saved is None:
        saved = './'

    os.makedirs(saved, exist_ok=True)

    seed_everything(0)

    # for srcp in tqdm(load_exec_list(exec_list)):
    if osp.isfile(srcp):
        srcp = osp.dirname(srcp)
    try:
        fullpage, infos, part_dict_list = load_parts(srcp)
    except Exception as e:
        print(f'failed to load {srcp}: \n')
        print(e)

    # optim_before = img_alpha_blending(part_dict_list, final_size=(1024, 1024))
    optim_depth(part_dict_list, fullpage)

    n_components = len(part_dict_list)

    colors = []
    tag_list = []
    for ii in range(len(part_dict_list)):
        pd = part_dict_list[ii]
        depth = pd['depth']
        h, w = depth.shape[:2]
        pd['depth_median'] = np.median(depth[pd['mask']])
        tag_list.append(pd['tag'])
        color = get_color(VALID_BODY_PARTS_V2.index(pd['tag']))
        alpha = pd['img'][..., 3]
        colors.append(color)
        pd['img'] = np.full((h, w, 4), (*color, 255))
        pd['img'][..., 3] = alpha
        # pd.pop('depth')

    part_dict_list.sort(key=lambda x: x['depth_median'], reverse=True)
    color_code = img_alpha_blending(part_dict_list, final_size=(1024, 1024))

    save_dir = osp.join(saved, osp.basename(osp.dirname(srcp)))
    os.makedirs(save_dir, exist_ok=True)
    savep = osp.join(save_dir, osp.basename(srcp)) + '.png'

    alpha = (color_code[..., [3]] / 255.) * 0.8
    blended = alpha * color_code[..., :3] + (1 - alpha) * fullpage[..., :3]
    result = np.round(blended).astype(np.uint8)

    # print('xxxxx')

    colors = np.array(colors)
    colors = colors.astype(np.float32) / 255.
    px = 1 / plt.rcParams['figure.dpi']  # pixel in inches
    fig = plt.figure(figsize=(result.shape[1] * px, result.shape[0] * px), facecolor=[0, 0, 0, 0])
    
    fnt_sz = int(5 * result.shape[0] / 256)
    plt.rcParams['legend.fontsize'] = fnt_sz
    lw = 5 * result.shape[0] / 256
    lines = [Line2D([0], [0], color=colors[i], lw=lw)
                for i in range(n_components)]
    # c_labels = [all_labels[i] for i in all_labels]
    plt.legend(lines,
                tag_list,
                mode="expand",
                fancybox=False,
                edgecolor="black",
                # frameon=False,
                shadow=False,
                framealpha=0.)

    plt.tight_layout(pad=0, w_pad=0, h_pad=0)
    plt.axis('off')
    fig.canvas.draw()
    data = np.frombuffer(fig.canvas.buffer_rgba() , dtype=np.uint8)
    plt.close(fig=fig)
    data = data.reshape(fig.canvas.get_width_height()[::-1] + (4,))
    dx, dy, dw, dh = cv2.boundingRect(cv2.findNonZero(data[..., 3]))
    
    data = rgba_to_rgb_fixbg(data[:, dx: dx + dw])
    data = cv2.copyMakeBorder(data, 0, 0, fnt_sz, fnt_sz, borderType=cv2.BORDER_CONSTANT, value=(255, 255, 255))

    result = np.hstack((result, data))
    Image.fromarray(result).save(savep)
    
    print(f'result saved to {savep}')