import { generator } from '@whisklabs/grpc/generator';

const error = await generator({
  dir: 'source/folder', // path to root of proto folder
  out: 'result/folder', // output path for generated result
  version: '№123', // optional string for version
  exclude: /some|regexp/, // optional regexp for exclude files
  debug: true, // generate json debug files,
  messageRequired: false, // enable strict required mode for messages (default: false)
  // If we need package.json, set options packageName and packageVersion
  packageName: '@whisklabs/package-one', // generate package.json with name
  packageVersion: '0.1.10', // generate package.json with version
  packageUrl: '[email protected]:whisklabs/npm.git', // set package url
  packageRegistry: 'https://npm.pkg.github.com/', // set package registry
});

console.log(error); // true | false

import { readFileSync } from 'fs';
import { parser } from '@whisklabs/grpc';

const parsed = parser(readFileSync('some.proto', 'utf8'));

// Importing library
import { grpcHTTP, StatusCode } from '@whisklabs/grpc';

// Server gRPC instance
export const grpc = grpcHTTP({
  // URL to API server [Required]
  server: 'https://example.com', // [default = `${server}/${methodName}`]
  // or custom server url
  server: (method) => `https://example.com/my/path/${method}?param_any=example`
  // Use or not credentials [default = true]
  credentials: true,
  // Send binary data of request/response to grpc-web devtools [default = false]
  debug: false,
  // Send JSON data of request/response to grpc-web devtools [default = false]
  devtool: false,
  // Instance of any console. Work with combine debug or devtool [default = undefined]
  logger: console,
  // Setup global timeout in number milliseconds [default = undefined]
  timeout: undefined,

  // Proxy xhr before request
  transformRequest: ({ xhr, data, meta }) => {
    xhr.setRequestHeader('Authorization', 'ANY_TOKEN');
  },

  // Or example with modify data before send
  transformRequest: async ({ data }) => {
    if (isObject(data)) {
      (data as any).token = await SomeAction();
      return data;
    }
    return { ...data, x: 1 };
  },

  // Proxy result after request
  transformResponse: ({ xhr, data, meta }) => {
    if (!data.success) {
      console.log(data.error);
    }

    // Passthrough without changes
    return data;
  },

  // Proxy result after request (async example)
  transformResponse: async ({ data }) => {
    // We can globaly check errors
    if (!data.success) {
      // Notify
      alert(`v1.Grpc.Event.GRPCError ${data.error.message}`);

      // Prevent
      if (data.error.httpStatus === 403) {
        const reason = await forbidden();
        return { success: false, error: { message: reason } };
      }

      // Redirect
      if (data.error.grpcCode === StatusCode.UNAUTHENTICATED) {
        logout();
      }
    }

    // Passthrough without changes
    return data;
  },
});

// Importing generated code from proto files
import { whisk_api_user_v2_UserAPI_GetMe } from './proto';

// Importing gRPC instance
import { grpc } from './grpc';

// You not need use catch for more flatten code without try {}
const user = await grpc(whisk_api_user_v2_UserAPI_GetMe);

console.log(user.success && user.data.user?.email);
console.log(!user.success && user.error.message);

if (user.success) {
  // If success we have typed data
  // You don't need do any extra check
  console.log(user.data.user?.email);
} else {
  // If error we have same structure with optional fields
  console.log(
    user.error.message, // string?
    user.error.data, // unknown? | Object - lib tries do safe JSON.parse
    user.error.grpcCode, // number?
    user.error.httpStatus // number?
  );
}

// Destruction example for flatten style
const { data: me, error } = await grpc(whisk_api_user_v2_UserAPI_GetMe);

console.log(me?.user?.email);
console.log(error?.message);

if (me) {
  console.log(me.user?.email);
}

if (error) {
  console.log(error.message);
}

// Importing
import { grpcCancel } from '@whisklabs/grpc';

// Cancel controller
const cancel = grpcCancel();

document.body.addEventListener('click', () => {
  cancel();
  console.log('gRPC canceled');
});

// Method call
const result = await grpc(whisk_api_user_v2_UserAPI_GetMe, { cancel });

if (result.success) {
  console.log(result.data.user?.id);
}

// Start 1 request
grpc(whisk_api_user_v2_UserAPI_GetMe, { cancel: `some-token` });
// Stopped 1 request, because cancel ID already in progress,
// and after this start 2 request
grpc(whisk_api_user_v2_UserAPI_GetMe, { cancel: `some-token` });
// Start 3 request and NOT stopped 2 request,
// because it's another cancel ID
grpc(whisk_api_user_v2_UserAPI_GetMe, { cancel: `some-token-${123}` });

import { whisk_api_user_v2_UserAPI_UpdateSettings } from './proto';
import { mask, maskWrap } from '@whisklabs/grpc';

// Manual example - the most reliable, because we do not have a single standard for masks
const settings = { personalDetails: { age: 1 } };
const mask = mask(settings);

await grpc(whisk_api_user_v2_UserAPI_UpdateSettings, { settings, mask });

// Wrapper (some projects)
await grpc(
  whisk_api_user_v2_UserAPI_UpdateSettings,
  maskWrap({ settings: { personalDetails: { age: 1 } } }, 'settings')
  // maskWrap({ settings: { personalDetails: { age: 1 } } }, 'settings', 'otherName')
);

// Built-in wrapper (some projects)
await grpc(
  whisk_api_user_v2_UserAPI_UpdateSettings,
  { settings: { personalDetails: { age: 1 } } },
  { mask: { field: 'settings'}
  // or with custom mask name
  // { mask: { field: 'settings', outField: 'otherName' }
);

// Semi-automatic wrapper for current object (some projects)
await grpc(
  whisk_api_user_v2_UserAPI_UpdateSettings,
  { settings: { personalDetails: { age: 1 } } },
  { mask: true }
);

// Automatic wrapper (waiting for the standard). Future - not implemented yet!
await grpc(
  whisk_api_user_v2_UserAPI_UpdateSettings,
  { settings: { personalDetails: { age: 1 } } }
);

interface Meta {
  token: string;
}

const grpc = grpcHTTP<Meta>(...);

const result = await grpc(
  whisk_api_user_v2_UserAPI_UpdateSettings, // gRPC method
  { ... }, // gRPC params
  { // Query options
    mask: { field: 'settings'}, // { field: string, outField?: string } | boolean - mask
    cancel: `some-token-${123}`, // string | grpcCancel - cancel request
    onDownload: e => console.log(e.loaded / e.total), // download progress with ProgressEvent
    onUpload: e => console.log(e.loaded / e.total), // upload progress with ProgressEvent
    timeout: 2000, // number - timeout for this request with cancel request at the end
    meta: { // Meta - data for transformRequest and transformResponse methods
      token: 'CODE',
    },
  }
);

grpcHTTP({
  // Send binary data of request/response to grpc-web devtools [default = false]
  debug: true,
  // Send JSON data of request/response to grpc-web devtools [default = false]
  devtool: true,
  ...
});

import { ServiceRequest, ServiceResponse } from '@whisklabs/grpc';
import { whisk_api_user_v2_UserAPI_UpdateSettings } from './proto';

// Manual types
type request = ServiceRequest<whisk_api_user_v2_UserAPI_UpdateSettings>;
type response = ServiceResponse<whisk_api_user_v2_UserAPI_UpdateSettings>;

import { GRPCDeep, grpcHTTP } from '@whisklabs/grpc';

const grpc = grpcHTTP({ ... }) as GRPCDeep;

import { FieldGetDeep, ServiceRequestDeep, ServiceResponseDeep } from '@whisklabs/grpc';

import { Default } from '@whisklabs/grpc';
import { whisk_api_user_v2_TestItem } from './proto';

const res = Default(whisk_api_user_v2_TestItem);

// res return new default object with required fields
// {
//   id: '',
//   array: [],
//   date: { day: 0, month: 0, year: 0 },
//   mapSearch: {},
//   name: '',
//   searches: [],
// };

import { unwrap } from '@whisklabs/grpc';

const userEmail = await unwrap(
  grpc(whisk_api_user_v2_UserAPI_UpdateSettings, { id: 'abc' }),
  data => data.user?.email,
  e => {
    console.log(e);
    return 1000;
  }
);

const user = await grpc(whisk_api_user_v2_UserAPI_GetMe);
const item = await unwrap(
  user,
  async success => {
    /* ... */
  },
  async error => {
    /* ... */
  }
);

// throw as usual promise
const err = e => {
  throw e;
};

try {
  const request = grpc(whisk_api_user_v2_UserAPI_GetMe);
  const email = await unwrap(request, data => data.user?.email, err);
} catch (e) {
  console.error(e);
}

type TestItem = {
  id: string;
  description?: string;
  item?: TestItem_InnerItem;
  array: boolean[];
  mapSearch: Record<string, OtherItem>;
};

type TestItem_InnerItem = {
  id: number;
};

type OtherItem = {
  count: number;
};

type TestItem = {
  id?: Type;
  forced: Type;
  dir?: Direction;
};

const enum Type {
  HEIGHT = 1,
  WIDTH = 2,
}

const enum Direction {
  UP = 0,
  DOWN = 1,
}

type Request = {
  id: number;
};

type Response = {
  name: string;
};

export type UserAPI_GetMe = Service<Field<Request>, Field<Response>>;

// get back

type request = ServiceRequest<UserAPI_GetMe>;
type response = ServiceResponse<UserAPI_GetMe>;

export type whisk_api_user_v2_TestOneof = {
  id: string;
  device?:
    | { oneof: 'deviceType'; value: whisk_api_user_v2_EthicalPreference }
    | { oneof: 'customDevice'; value: string };
};

const data: whisk_api_user_v2_TestOneof = {
  id: '123',
  device: {
    oneof: 'customDevice',
    value: 'abc',
  },
};

// any value
const any = oneof(data.device);
// or
const val = data.device?.value;

// oneis example
if (oneis(data.device, 'customDevice')) {
  console.log(data.device?.value);
}

// If example
if (data.device?.oneof === 'customDevice') {
  console.log(data.device?.value);
}

// Limit value variants
const a = oneof(data.device, 'customDevice') ?? oneof(data.device, 'deviceType');
console.log(a);

// Function transform
const out = oneof(data.device, 'customDevice', v => `${v}a`) ?? oneof(data.device, 'deviceType', v => v * 3);
console.log(out);

// Switch example
let res: string | number | undefined;
switch (data.device?.oneof) {
  case 'customDevice':
    res = `${data.device.value}a`;
    break;
  case 'deviceType':
    res = data.device.value * 3;
    break;
}
console.log(res);

export type whisk_api_user_v2_TestOneof = {
  id: string;
  name: string;
  item?: string;

  description?: string;
  test: string;
  result?: string;
  story?: string;

  time?: whisk_api_shared_v1_Time;
  date: whisk_api_shared_v1_Date;
  dateNew: whisk_api_shared_v1_Date;
};

type Test = {
  id: string;
  text?: string;
  currentWeek: Week;
  nextWeek?: Week;
  time: whisk_api_shared_v1_Time;
  timeAfter?: whisk_api_shared_v1_Time;
  description: string;
  item?: string;
  test: string;
  array: boolean[];
  array_2?: boolean[];
  mapSearch: Record<string, boolean>;
  mapSearch_2?: Record<string, boolean>;
  deviceDescription?:
    | { oneof: 'deviceType'; value: Device_DeviceType }
    | { oneof: 'customDevice'; value?: Device_DeviceType };
};

export type whisk_api_user_v2_TestOneof = {
  /**  @deprecated true */
  id: string;
  /**  @deprecated true */
  description: string;
};