import { ChangeDetectorRef, Component, EventEmitter, Input, OnChanges, OnInit, Output, ViewChild } from '@angular/core';
import { ModalHelper, _HttpClient } from '@delon/theme';
import { NzFormatEmitEvent, NzTreeNodeOptions } from 'ng-zorro-antd/core/tree';
import { NzTreeComponent } from 'ng-zorro-antd/tree';
import { SystemService } from '../../../services/system.service';
import { Funcs } from './funcs';

@Component({
  selector: 'app-cuc-menu',
  templateUrl: './menu.component.html',
  styleUrls: ['menu.less']
})
export class SettingMenuComponent implements OnInit {
  @ViewChild('nzTreeComponent', { static: false }) nzTreeComponent!: NzTreeComponent;
  origin: any = { buttonInfoList: Funcs[0].children, dictList: Funcs[0].children };
  node: any = {};
  authority: any[] = [];
  defaultSelectedKeys: any[] = [];
  defaultExpandedKeys: any[] = [];
  defaultCheckedKeys: any[] = [];
  functionList: any[] = Funcs;
  selectProject: any = {};
  selectApp: any = {};
  @Input() type = 'edit';
  @Input() source = '';
  @Input() isAuthorityIdDTOList: any[] = [];
  @Input() authorityAssistId: any[] = [];
  @Input() roleId: any;
  @Output() changeData = new EventEmitter();
  constructor(public service: SystemService, private cdr: ChangeDetectorRef) {}

  ngOnInit() {
    if (this.type === 'edit') {
      this.authority = this.isAuthorityIdDTOList;
    }
  }
  getAllFunction() {
    this.service.request(this.service.$api_getAllFunctionInfoByAppId, { appId: '' }, 'POST', true, 'FORM').subscribe(res => {
      if (this.source === 'onlyRelationAuth') {
        this.addDisabledTree(res);
      } else {
        // this.addDisabledLeafTree(res);
      }
      this.functionList = res;
      this.defaultCheckedKeys = this.authorityAssistId;
      this.cdr.detectChanges();
    });
  }
  addAuthority(origin: { id: any; all: any }, node: { buttonInfoList: any[] }, item?: { checked: any; id: any }) {
    if (this.authority.length && this.authority.filter(authItem => authItem.authorityId === origin.id).length) {
      // 判断此菜单权限是否已经存在权限列表中
      // 当前操作菜单id存在权限列表里
      this.authority.forEach((menuItem, menuIndex) => {
        if (menuItem.authorityId === origin.id) {
          menuItem.buttonAuthorityIds = menuItem.buttonAuthorityIds || []; // 防止属性不存在，给属性指定数据类型
          if (item) {
            // 单选
            if (item.checked) {
              if (menuItem.buttonAuthorityIds.indexOf(item.id) === -1) {
                // 如果该按钮在数据权限数组中不存在
                menuItem.buttonAuthorityIds.push(item.id);
              }
            } else {
              if (menuItem.buttonAuthorityIds && menuItem.buttonAuthorityIds.length) {
                menuItem.buttonAuthorityIds.forEach((btnItem: any, index: any) => {
                  if (btnItem === item.id) {
                    menuItem.buttonAuthorityIds.splice(index, 1);
                  }
                });
              }
            }
          } else {
            // 全选
            if (origin.all) {
              node.buttonInfoList.forEach((nodeItem: { id: any; checked: boolean }) => {
                if (menuItem.buttonAuthorityIds.indexOf(nodeItem.id) === -1) {
                  menuItem.buttonAuthorityIds.push(nodeItem.id);
                  nodeItem.checked = true;
                }
              });
            } else {
              if (menuItem.buttonAuthorityIds && menuItem.buttonAuthorityIds.length) {
                menuItem.buttonAuthorityIds = [];
                node.buttonInfoList.forEach((nodeItem: { checked: boolean }) => {
                  nodeItem.checked = false;
                });
              }
            }
          }
        }
      });
    } else {
      // 数组为空的时候
      const buttonAuthorityIds = [];
      if (item) {
        // 全选
        buttonAuthorityIds.push(item.id);
      } else {
        node.buttonInfoList.forEach((nodeItem: { id: any; checked: boolean }) => {
          if (origin.all) {
            buttonAuthorityIds.push(nodeItem.id);
            nodeItem.checked = true;
          }
        });
      }
      const obj: any = {
        authorityId: origin.id,
        buttonAuthorityIds
      };
      this.authority.push(obj);
    }
    this.checkTreeNode(node, origin);
  }
  addDict(item: { checked: any; itemId: any; itemKey: any }, dictItem: { dictId: any }, origin: { id: any }, node: any) {
    if (this.authority.length) {
      // 判断此菜单权限是否已经存在权限列表中
      if (this.authority.filter(authItem => authItem.authorityId === origin.id).length) {
        // 当前操作菜单id存在权限列表里
        this.authority.forEach((menuItem, menuIndex) => {
          if (menuItem.authorityId === origin.id) {
            menuItem.dataAuthority = menuItem.dataAuthority || []; // 防止属性不存在，给属性指定数据类型
            if (item.checked) {
              if (menuItem.dataAuthority.filter((ele: { dictItemId: any }) => ele.dictItemId === item.itemId).length === 0) {
                // 如果该按钮在数据权限数组中不存在
                menuItem.dataAuthority.push({ dictItemId: item.itemId, itemKey: item.itemKey, dictId: dictItem.dictId });
              }
            } else {
              if (menuItem.dataAuthority && menuItem.dataAuthority.length) {
                menuItem.dataAuthority.forEach((btnItem: { dictItemId: any }, index: any) => {
                  if (btnItem.dictItemId === item.itemId) {
                    menuItem.dataAuthority.splice(index, 1);
                  }
                });
              }
            }
          }
        });
      } else {
        // 当前操作菜单id不存在权限列表里
        const dataAuthority = [];
        dataAuthority.push({ dictItemId: item.itemId, itemKey: item.itemKey, dictId: dictItem.dictId });
        const obj: any = {
          authorityId: origin.id,
          dataAuthority
        };
        this.authority.push(obj);
      }
    } else {
      // 数组为空的时候
      const dataAuthority = [];
      dataAuthority.push({ dictItemId: item.itemId, itemKey: item.itemKey, dictId: dictItem.dictId });
      const obj: any = {
        authorityId: origin.id,
        dataAuthority
      };
      this.authority.push(obj);
    }
    this.checkTreeNode(node, origin);
  }
  checkTreeNode(node: any, origin: { id: any }) {
    const checkedNode: any = this.nzTreeComponent.getCheckedNodeList();
    const allCheckedArr: any[] = [];
    this.overTree(checkedNode, allCheckedArr);
    this.authority.forEach(authItem => {
      if (authItem.authorityId === origin.id) {
        if (
          (authItem.buttonAuthorityIds && authItem.buttonAuthorityIds.length) ||
          (authItem.dataAuthority && authItem.dataAuthority.length)
        ) {
          if (allCheckedArr.indexOf(node.key) === -1) {
            allCheckedArr.push(node.key);
          }
        } else {
          if (allCheckedArr.indexOf(node.key) !== -1) {
            allCheckedArr.forEach((ele, index) => {
              if (ele === origin.id) {
                allCheckedArr.splice(index, 1);
              }
            });
          }
        }
      }
    });
    this.defaultCheckedKeys = allCheckedArr;
  }
  addAuthorityAll(origin: any, node: { checked: any; buttonInfoList: any[] }) {
    if (node.checked) {
      node.buttonInfoList.forEach((item: any) => {});
    } else {
    }
  }
  overTree(children: any[], a: any[]) {
    children.forEach(item => {
      a.push(item.key);
      if (item.isLeaf) {
        return;
      }
      if (item.children && item.children.length) {
        this.overTree(item.children, a);
      }
    });
  }
  // 获取角色模板权限
  getRoleTpl(id: any) {
    const params = {
      id
    };
    this.service.request(this.service.$api_getRoleTemplateInfo, params).subscribe(res => {
      this.authority = res.authority;
      this.defaultCheckedKeys = res.authorityAssistId;
    });
  }
  addDisabledTree(arr: any[]) {
    arr.forEach((item: any) => {
      item.disableCheckbox = true;
      if (item.isLeaf) {
        return;
      }
      if (item.children && item.children.length) {
        this.addDisabledTree(item.children);
      }
    });
  }
  addDisabledLeafTree(arr: any[]) {
    arr.forEach((item: any) => {
      if (item.isLeaf) {
        return;
      }
      item.disableCheckbox = true;
      if (item.children && item.children.length) {
        this.addDisabledLeafTree(item.children);
      }
    });
  }
  nzEvent(event: any): void {
    const ele = event.event.target as HTMLElement;
    this.origin = event.node.origin;
    this.node = event.node.origin;
    if (!event.node.origin.isLeaf) {
      event.node.isExpanded = !event.node.isExpanded;
    } else {
      // this.initButtonList(event.node.key, event.node.origin);
      // this.initDictList(event.node.key, event.node.origin);
    }
  }

  washTree() {
    const authorityMenu: any[] = []; // this.authority
    const tempAuthorityIdDTOListMenu: any[] = [];
    const checkedNode: any = this.nzTreeComponent.getCheckedNodeList();
    const halfCheckedNode: any = this.nzTreeComponent.getHalfCheckedNodeList();
    this.authorityAssistId = [];
    halfCheckedNode.forEach((item: { key: any }) => {
      authorityMenu.push({ authorityId: item.key });
      tempAuthorityIdDTOListMenu.push(item.key);
    });
    this.overWashTree(checkedNode, tempAuthorityIdDTOListMenu, authorityMenu);
    if (this.authority && this.authority.length) {
      this.authority.forEach(item => {
        if (tempAuthorityIdDTOListMenu.indexOf(item.authorityId) !== -1) {
          tempAuthorityIdDTOListMenu.forEach((oldItem, oldIndex) => {
            if (oldItem === item.authorityId) {
              authorityMenu[oldIndex] = item;
            }
          });
        }
      });
    }
    const result = {
      authority: authorityMenu,
      authorityAssistId: this.authorityAssistId
    };
    this.changeData.emit(result);
  }
  overWashTree(children: any[], tempAuthorityIdDTOListMenu: any[], authorityMenu: any[]) {
    children.forEach((item: any) => {
      this.authorityAssistId.push(item.key);
      tempAuthorityIdDTOListMenu.push(item.key);
      authorityMenu.push({ authorityId: item.key });
      if (item.isLeaf) {
        return;
      }
      if (item.children) {
        this.overWashTree(item.children, tempAuthorityIdDTOListMenu, authorityMenu);
      }
    });
  }
  initButtonList(id: any, origin: any) {
    const params = {
      id
    };
    this.service.request(this.service.$api_getFunctionButtonInfo, params).subscribe(res => {
      if (res) {
        origin.buttonInfoList = res;
        origin.all = false;
        // 判断此菜单下是否已有此按钮权限
        this.againGetBtn(id, origin);
      }
    });
  }
  // 再次请求,需要判断暂存权限数组是否已有此权限
  againGetBtn(id: any, origin: any) {
    if (this.authority.length === 0) {
      return;
    }
    this.authority.forEach(item => {
      if (item.authorityId === id) {
        // 如果当前菜单Id等于暂存权限数组的Id
        if (item.buttonAuthorityIds && item.buttonAuthorityIds.length) {
          // 如果当前菜单Id权限数组不为空
          origin.buttonInfoList.forEach((btnItem: { id: any; checked: boolean }) => {
            // 判断已有权限id是否存在
            if (item.buttonAuthorityIds.indexOf(btnItem.id) !== -1) {
              btnItem.checked = true;
            } else {
              btnItem.checked = false;
            }
          });
        }
      }
    });
  }
  initDictList(id: any, origin: any) {
    const params = {
      id
    };
    this.service.request(this.service.$api_getFunctionDataInfo, params).subscribe(res => {
      if (res) {
        origin.dictList = res;
        // 判断此菜单下是否已有此按钮权限
        this.againGetDict(id, origin);
      }
    });
  }
  // 再次请求,需要判断暂存权限数组是否已有此权限
  againGetDict(id: any, origin: any) {
    if (this.authority.length === 0) {
      return;
    }
    this.authority.forEach(item => {
      if (item.authorityId === id) {
        // 如果当前菜单Id等于暂存权限数组的Id
        if (item.dataAuthority && item.dataAuthority.length) {
          // 如果当前菜单Id权限数组不为空
          origin.dictList.forEach((ele: { dictItem: any[] }) => {
            // 判断已有权限id是否存在
            ele.dictItem.forEach((dictItem: { itemId: any; checked: boolean; cheked: boolean }) => {
              item.dataAuthority.forEach((dataItem: { dictItemId: any }) => {
                if (dataItem.dictItemId === dictItem.itemId) {
                  dictItem.checked = true;
                } else {
                  dictItem.cheked = false;
                }
              });
            });
          });
        }
      }
    });
  }
}
