import { inject, injectable } from 'inversify';
import { WorkspaceService } from '@gedit/workspace-2d/lib/browser';
import { NavigatorDirNode, NavigatorResourceNode, NavigatorTreeNode } from '../common/navigator-resource-node';
import { OpenerService } from '@gedit/application-common/lib/browser';
import { FileStat, URI } from '@gedit/utils';
import { NavigatorFileContributionRegistry } from './navigator-file-contribution';

@injectable()
export class NavigatorResourceProvider {
  @inject(OpenerService) protected readonly openerService: OpenerService;
  @inject(WorkspaceService) protected readonly workspaceService: WorkspaceService;
  @inject(NavigatorFileContributionRegistry) protected readonly fileRegistry: NavigatorFileContributionRegistry;

  async ready(): Promise<boolean> {
    await this.workspaceService.getCurrentRoot();
    return true;
  }

  async createRoot(): Promise<NavigatorDirNode | undefined> {
    const root = await this.getWorkspaceRoot();
    const workspaceName = await this.workspaceService.getWorkspaceName();
    if (!root) {
      return undefined;
    }
    return NavigatorDirNode.createRoot(root, workspaceName || new URI(root.uri).displayName);
  }
  async resolveChildren(parent: NavigatorTreeNode): Promise<NavigatorTreeNode[]> {
    if (NavigatorDirNode.isRootNode(parent)) {
      return this.fileRegistry.fileNodes.map((f, index) => this.toTreeNode(f, parent));
    }
    if (NavigatorDirNode.is(parent)) {
      const resolver = this.fileRegistry.childrenResolvers.find(r => r.canHandle((parent as NavigatorTreeNode).resource));
      if (resolver) {
        return Promise.resolve(resolver.resolveChildren((parent as NavigatorTreeNode).resource)).then(nodes =>
          nodes.map((node: NavigatorResourceNode) => this.toTreeNode(node, parent))
        );
      }
      return [];
    }
    return [];
  }
  moveTo(parentNode: NavigatorResourceNode, fromNode: NavigatorResourceNode, toNode?: NavigatorResourceNode): void {
    const resolver = this.fileRegistry.childrenResolvers.find(r => r.canHandle(parentNode));
    if (resolver && resolver.moveTo) {
      resolver.moveTo(fromNode, toNode);
    }
  }
  toTreeNode(resourceNode: NavigatorResourceNode, parent: NavigatorTreeNode, expanded: boolean = false): NavigatorTreeNode {
    const uri = resourceNode.uri ? new URI(resourceNode.uri) : parent.uri.resolve(resourceNode.uriPath || '');
    const node: NavigatorTreeNode = {
      id: uri.toString(),
      name: resourceNode.label,
      parent: undefined,
      uri,
      resource: resourceNode,
      selected: false,
    };
    if (resourceNode.isDirectory) {
      node.expanded = expanded;
      node.children = [];
    }
    return node;
  }
  protected async getWorkspaceRoot(): Promise<FileStat | undefined> {
    return this.workspaceService.getCurrentRoot();
  }
}