import axios, { AxiosInstance } from 'axios';
import { BaseApiClass, BaseApiClassConstructor } from '../extensions';
import { DecodeBase64Str } from '../helpers';
import { HttpClient } from '../clients';

const OWNER = 'hexasync-saas';

/* ------------------ Resource Interface ------------------------ */

interface GitTree {
  sha: string;
  url: string;
  truncated: boolean;
  tree: {
    path: string;
    mode?: string;
    type?: string;
    sha?: string;
    size?: number;
    url: string;
  }[];
}

enum GitBlobEncoding {
  BASE64 = 'base64',
}

export interface GitBlob {
  content: string;
  encoding: GitBlobEncoding;
  url: string;
  sha: string;
  size: number | null;
  node_id: string;
  highlighted_content?: string;
}

/* ------------------ Request/Response Interface ------------------------ */

export interface GetTreeByWorkingRefRequest {
  workingRef: string;
}

interface GetTreeByWorkingRefResponse extends GitTree {}

interface GetTreeByFullUrlRequest {
  url: string;
}

interface GetTreeByFullUrlResponse extends GitTree {}

interface GetBlobByFullUrlRequest {
  url: string;
}

interface GetBlobByFullUrlResponse extends GitBlob {}

/* ------------------ Class Interface ------------------------ */

export interface GitHubProviderConstructor {
  accessToken?: string;
  repository: string;
}

interface _GitHubApiConstructor
  extends
    Omit<GitHubProviderConstructor, 'accessToken'>,
    BaseApiClassConstructor {}

/* ------------------ Class ------------------------ */

class _GitHubApi extends BaseApiClass {
  repository = '';

  constructor({ httpClient, repository }: _GitHubApiConstructor) {
    super({ httpClient });
    this.repository = repository;
  }
}

class _GitHubRESTApi extends _GitHubApi {
  constructor(args: _GitHubApiConstructor) {
    super(args);
  }

  async GetTreeByWorkingRef({ workingRef }: GetTreeByWorkingRefRequest) {
    const reqUrl = `/repos/${OWNER}/${this.repository}/git/trees/${workingRef}`;
    const resp =
      await this.httpClient.instance.get<GetTreeByWorkingRefResponse>(reqUrl);
    return resp.data;
  }

  async GetTreeByFullUrl({ url }: GetTreeByFullUrlRequest) {
    const resp =
      await this.httpClient.instance.get<GetTreeByFullUrlResponse>(url);
    return resp.data;
  }

  async GetBlobByFullUrl({ url }: GetBlobByFullUrlRequest) {
    const resp =
      await this.httpClient.instance.get<GetBlobByFullUrlResponse>(url);
    return resp.data;
  }

  DecodeBlobContent({ encoding, content }: GitBlob) {
    var result = '';

    switch (encoding) {
      case GitBlobEncoding.BASE64:
        result = DecodeBase64Str(content);
        break;
      default:
        throw new Error(
          'GitHubProvider.ts > _GitHubRESTApi > GetBlobByFullUrl error: blob.encoding type has not been defined',
        );
    }

    return result;
  }
}

class _GitHubGraphQLApi extends _GitHubApi {
  constructor(args: _GitHubApiConstructor) {
    super(args);
  }
}

export class GitHubProvider {
  rest!: _GitHubRESTApi;
  graphql!: _GitHubGraphQLApi;

  constructor(args: GitHubProviderConstructor) {
    const { accessToken } = args;

    const httpClient = new HttpClient({
      baseURL: 'https://api.github.com', // TODO: Refactor to .env
      headers: {
        Authorization: `token ${accessToken}`,
        'User-Agent': 'hexasync-cli',
      },
    });
    this.rest = new _GitHubRESTApi({
      ...args,
      httpClient,
    });
    this.graphql = new _GitHubGraphQLApi({
      ...args,
      httpClient,
    });
  }
}