using MRGS;

public class MasterController : MonoBehaviour
{
    void Awake()
    {
        // Configuring MRGS Parameters
        // ...

        var modulesParams = new List<MRGSExternalSDKSettings>
        modulesParams.Add(new MRGSMyGamesParams("<MYGAMES_CLIENT_ID>")

        // Configuring External SDKs and initializing MRGS
        // ...

        MRGService.Instance.Initialize(serviceParams, sdkParams)
    }
}

@import MRGService;

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    //Configuring MRGS Parameters
    // ...
    //Configuring External SDKs

    MRGSMyGamesParams* mygamesLoginParams = [[MRGSMyGamesParams alloc] initWithClientId:@"CLIENT_ID"];

    NSArray *externalParams = @[ ..., mygamesLoginParams];
    [MRGService startWithServiceParams:<params> externalSDKParams:externalParams delegate:nil];
}

import java.util.ArrayList;
import java.util.List;

import games.my.mrgs.MRGSModuleParams;
import games.my.mrgs.MRGService;
import games.my.mrgs.authentication.MRGSMyGamesAuthParams;

public class YourApplicationClass extends Application {
    @Override
    public void onCreate() {
        super.onCreate();

        // Setting MRGService
        final MRGServiceParams serviceParams = ...;
        // Setting External SDKs
        final List<MRGSModuleParams> moduleParams = new ArrayList<>();
        moduleParams.add(MRGSMyGamesAuthParams.init("<CLIENT_ID>"));

        MRGService.service(context, serviceParams, moduleParams);
    }
}

var myGamesParams = new MRGSMyGamesParams("<CLIENT_ID>")
{
    CustomHost = "vkplay.ru",
};

MRGSMyGamesParams* mygamesLoginParams = [[MRGSMyGamesParams alloc] initWithClientId:@"CLIENT_ID"];
mygamesLoginParams.customHost = @"vkplay.ru";

import games.my.mrgs.authentication.MRGSMyGamesAuthParams;

final MRGSMyGamesAuthParams myGamesAuthParams = MRGSMyGamesAuthParams.init("<CLIENT_ID>");
myGamesAuthParams.setHost("vkplay.ru");

var myGamesParams = new MRGSMyGamesParams("<CLIENT_ID>")
{
    UseDevEnvironment = true
};

MRGSMyGamesParams* mygamesLoginParams = [[MRGSMyGamesParams alloc] initWithClientId:@"CLIENT_ID"];
mygamesParams.useDevEnvironment = YES;

import games.my.mrgs.authentication.MRGSMyGamesAuthParams;

final MRGSMyGamesAuthParams myGamesAuthParams = MRGSMyGamesAuthParams.init("<CLIENT_ID>");
myGamesAuthParams.setDevEnvironment(true);

// Setting
// 'this' conforms to 'IMRGSAuthenticationDelegate' protocol
MRGSAuthenticationMyGames.Instance.Delegate = this;

// Implementation
// The method that is called when the user has logged out of the social network remotely, or his session has ended.
public void OnAuthenticationProviderDidLogoutUser(MRGSAuthentication provider, MRGSAuthenticationUser user){
    Debug.Log("MRGSAuthentication<Unity> - OnAuthenticationProviderDidLogoutUser: " + user + "\nNetwork: " + provider.SocialId().ToString());
}

// Setting
[MRGSAuthenticationMyGames sharedInstance].delegate = self;

//Implementation
// The method that is called when the user has remotely logged out of the social network, or his session has ended.
- (void)authenticationProvider:(id<MRGSAuthentication>)provider didLogoutUser:(MRGSAuthenticationUser *)user{
    NSLog(@"User did logout: \n%@", user);
}

// The method that is called when the controller needs to be displayed to authorize the user.
- (void)shouldPresentAuthorizationController:(UIViewController *)viewController {
    UIViewController *rootVC = [UIApplication sharedApplication].keyWindow.rootViewController;
    [rootVC presentViewController:viewController animated:YES completion:nil];
}

import androidx.annotation.NonNull;

import games.my.mrgs.authentication.MRGSAuthentication.OnExternalLogoutListener;
import games.my.mrgs.authentication.mygames.MRGSMyGames;

// Set a listener
MRGSMyGames.getInstance().setOnExternalLogoutListener(new OnExternalLogoutListener() {
    @Override
    public void onUserLogout(@NonNull String socialId) {
        // Handel result.
    }
});

bool isLoggedIn = MRGSAuthenticationMyGames.Instance.IsLoggedIn();

BOOL isLoggedIn = [[MRGSAuthenticationMyGames sharedInstance] isLoggedIn];

import games.my.mrgs.authentication.mygames.MRGSMyGames;

final boolean isLoggedIn = MRGSMyGames.getInstance().isLoggedIn();

// If error occured, error object will be non-null
MRGSAuthenticationMyGames.Instance.Login((MRGSError error) => {
    if (error == null) {
        // Auth success
    } 
});

// The response will include an object describing the user and the token, and an error object, if any.
MRGSAuthenticationMyGames.Instance.Login((MRGSAuthenticationCredential credentials, MRGSError error) => {
    Debug.Log("MRGSAuthenticationMyGames:\nCredentials: " + credentials + "\nError:\n" + error);
    if (error == null) {
        // Auth success
    }
});

// Only the error object will be returned in the response if it happened
[[MRGSAuthenticationMyGames sharedInstance] login:^(NSError *error) {
    if (!error) {
        // Auth success
    }
}];

// The response will contain an object describing the user and the token, and an error object if it happened
[[MRGSAuthenticationMyGames sharedInstance] loginWithCompletionHandler:^(MRGSAuthenticationCredential *credentials, NSError *error) {
    NSLog(@"Result - %@. Error - %@", credentials, error);
    if (!error) {
        // Auth success
    }
}];

import android.app.Activity;

import androidx.annotation.NonNull;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSCredentials;
import games.my.mrgs.authentication.MRGSLoginCallback;
import games.my.mrgs.authentication.mygames.MRGSMyGames;

MRGSMyGames.getInstance().login(activity, new MRGSLoginCallback() {
    @Override
    public void onSuccess(@NonNull MRGSCredentials credentials) {
        // Handle result.
    }

    @Override
    public void onError(@NonNull MRGSError error) {
        // Handle error.
    }
});

var scopes = new List<string>();

MRGSAuthenticationMyGames.Instance.Login(scopes, (MRGSAuthenticationCredential credentials, MRGSError error) => {
    Debug.Log("MRGSAuthenticationMyGames:\nCredentials: " + credentials + "\nError:\n" + error);
    if (error == null) {
        // Auth success
    }
});

[[MRGSAuthenticationMyGames sharedInstance] loginWithScopes:@[] completionHandler:^(MRGSAuthenticationCredential *credentials, NSError *error) {
    NSLog(@"Result - %@. Error - %@", credentials, error);
}];

import android.app.Activity;

import androidx.annotation.NonNull;

import java.util.Arrays;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSCredentials;
import games.my.mrgs.authentication.MRGSLoginCallback;
import games.my.mrgs.authentication.mygames.MRGSMyGames;

MRGSMyGames.getInstance().login(activity, Collections.emptyList(), new MRGSLoginCallback() {
    @Override
    public void onSuccess(@NonNull MRGSCredentials credentials) {
        // Handle result
    }

    @Override
    public void onError(@NonNull MRGSError error) {
        // Handle error.
    }
});

// The information about the user, identifier, name, email, etc.
MRGSAuthenticationMyGames.Instance.GetCurrentUser((MRGSAuthenticationUser user, MRGSError error) => {
    Debug.Log("MRGSAuthenticationMyGames:\User: " + user + "\nError:\n" + error);
    if (error == null) {
        // Work with user data
    }
});

// Information about the token, lifetime, etc.
MRGSAuthenticationMyGames.Instance.GetAccessToken((MRGSAuthenticationAccessToken token, MRGSError error) => {
    Debug.Log("MRGSAuthenticationMyGames:\Token: " + token + "\nError:\n" + error);
    if (error == null) {
        // Work with token info
    }
    else if (error.Code == (int)MRGSAuthenticationErrorCode.ConnectionFailed)
    {
        // No network, try later     
    }
    else
    {
        // Logout user from app (MRGS will logout automatically in SDK)
    }
});

// An object is returned that combines information about the user (identifier, name, email, etc.) and about the token.
[[MRGSAuthenticationMyGames sharedInstance] getCredentials:^(MRGSAuthenticationCredential *credentials, NSError *error) {
    NSLog(@"Result - %@. Error - %@", credentials, error);
    if(!error){
        // Credentials data work
    }
}];

// Returns separately information about the user, ID, name, email, etc.
[[MRGSAuthenticationMyGames sharedInstance] getCurrentUser:^(MRGSAuthenticationUser *user, NSError *error) {
    NSLog(@"User - %@. Error - %@", user, error);
    if(!error){
        // User data work
    }
}];

// Information about the token, lifetime, etc. is returned separately.
[[MRGSAuthenticationMyGames sharedInstance] getAccessToken:^(MRGSAuthenticationAccessToken *token, NSError *error) {
    if (!error) {
        NSLog(@"getAccessToken result - %@", token);
    } else {
        NSLog(@"getAccessToken error - %@", error);
    }
}];

import android.util.Log;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import games.my.mrgs.MRGSError;
import games.my.mrgs.authentication.MRGSAccessToken;
import games.my.mrgs.authentication.MRGSAuthentication;
import games.my.mrgs.authentication.MRGSUser;
import games.my.mrgs.authentication.mygames.MRGSMyGames;
import games.my.mrgs.utils.optional.BiConsumer;

// Returns user's information.
MRGSMyGames.getInstance().getCurrentUser(new MRGSAuthentication.UserCallback() {
    @Override
    public void onSuccess(@NonNull final MRGSUser user) {
    }

    @Override
    public void onError(@NonNull MRGSError error) {
    }
});

// Returns authentication's information.
MRGSMyGames.getInstance().getAccessToken(new BiConsumer<MRGSAccessToken, MRGSError>() {
    @Override
    public void accept(@Nullable MRGSAccessToken accessToken, @Nullable MRGSError error) {
        if (error != null) {
            Log.d("MRGSAuthentication", "AccessToken error: " + error.getErrorText());
        } else {
            Log.d("MRGSAuthentication", "AccessToken success: " + accessToken);
        }
    }
});

MRGSAuthenticationMyGames.Instance.Logout();

[[MRGSAuthenticationMyGames sharedInstance] logout];

import games.my.mrgs.authentication.mygames.MRGSMyGames;

MRGSMyGames.getInstance().logout();

MRGSAuthenticationMyGames.Instance.ShouldHideBrandOccurrences = true;

[MRGSAuthenticationMyGames sharedInstance].shouldHideBrandOccurrences = YES;

import games.my.mrgs.authentication.mygames.MRGSMyGames;

MRGSMyGames.getInstance().setHideBrandOccurrences(true);