package main

import (
  "log"
  "net/http"
  "time"

  dd "github.com/datadome/fraud-sdk-go"
)

func accountHandler(client *dd.Client) http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodPut {
      // Address field
      name := "Élysée Palace"
      line1 := "55 Rue du Faubourg Saint-Honoré"
      line2 := "2nd floor"
      city := "Paris"
      countryCode := "FR"
      regionCode := "75"
      zipCode := "75008"
      userAddress := dd.Address{
        City:        &city,
        CountryCode: &countryCode,
        Line1:       &line1,
        Line2:       &line2,
        Name:        &name,
        RegionCode:  &regionCode,
        ZipCode:     &zipCode,
      }

      // Authentication field
      authenticationMode := dd.Password
      authenticationSocialProvider := dd.Google
      authenticationType := dd.Social
      authentication := dd.Authentication{
        Mode:           &authenticationMode,
        SocialProvider: &authenticationSocialProvider,
        Type:           &authenticationType,
      }

      // User field
      createdAt := time.Now().Format(time.RFC3339)
      firstName := "Data"
      lastName := "Dome"
      title := "mr"
      phone := "+33978787878"
      email := "[email protected]"
      paymentMethodUpdated := true
      displayName := "DataDome 🤖"
      description := "Some Description / Некоторое описание"
      user := dd.User{
        ID:          "fake_user_id",
				Address:     &userAddress,
				CreatedAt:   &createdAt,
				Email:       &email,
				FirstName:   &firstName,
				LastName:    &lastName,
				Phone:       &phone,
				Title:       &title,
				DisplayName: &displayName,
				Description: &description,
				ExternalURLs: &[]string{
					"https://example.org/external1",
					"https://example.org/external2",
					"https://example.org/external3",
				},
				PictureURLs: &[]string{
					"https://example.org/image1.png",
					"https://example.org/image2.png",
					"https://example.org/image3.png",
				},
				PaymentMethodUpdated: &paymentMethodUpdated,
      }

      // Session field
      sessionId := "fake_session_id"
      session := dd.Session{
        ID:        &sessionId,
        CreatedAt: &createdAt,
      }

      validate, err := client.Validate(r, dd.NewAccountUpdateEvent(
        email,
        dd.AccountUpdateWithAuthentication(authentication),
        dd.AccountUpdateWithUser(user),
        dd.AccountUpdateWithSession(session),
      ))
      if err != nil {
        log.Printf("error during validation: %v\n", err)
      }
      if validate.Action == dd.Allow {
        w.WriteHeader(http.StatusOK)
        return
      } else {
        // Business Logic here
        // MFA
        // Challenge
        // Notification email
        // temporarly lock account
        http.Error(w, "failed", http.StatusForbidden)
        return
      }
    } else {
      http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
  }
}

func main() {
  client, _ := dd.NewClient("FRAUD_API_KEY")

  mux := http.NewServeMux()
  mux.HandleFunc("/account", accountHandler(client))

  _ = http.ListenAndServe(":8080", mux)
}

const datadomeClient = new DataDome("FraudAPIKey");

app.put('/account', async function (req, res) {
  const emailAccount = req.body.email;
  const session = { id: 'sessionId', createdAt: new Date() };
  
  const userAddress = {
    name: 'HQ',
    line1: '22 rue de la Michodiere',
    line2: '2nd floor',
    city: 'Paris',
    countryCode: 'FR',
    country: 'France',
    regionCode: '75',
    zipCode: '75002'
  };
  
  const user = {
    id: 'userId',
    title: 'mrs',
    firstName: 'Data',
    lastName: 'Dome',
    createdAt: new Date(),
    phone: '+33978787878',
    email: emailAccount,
    address: userAddress,
    displayName: 'DataDome 🤖',
    description: 'Some Description',
    externalUrls: [
    	'https://example.org/external1',
      'https://example.org/external2',
      'https://example.org/external3',
    ],
    pictureUrls: [
      'https://example.org/image1.png',
      'https://example.org/image2.png',
      'https://example.org/image3.png',
    ],
  };
  
  const authentication: Authentication = {
    socialProvider: 'google',
    type: 'social',
  	mode: 'password',
  };

  const accountUpdateEvent = new AccountUpdateEvent({
  	account: emailAccount,
	  authentication,
  	session,
	  user,
  });
  
  const datadomeResponse = await datadomeClient.validate(req, accountUpdateEvent);

  if (datadomeResponse?.action == ResponseAction.ALLOW) {
    // Process update of the account
    res.status(200).send(`Successfully updated user ${req.body.email}`);
  } else {
    res.status(401).send(`Access denied [by DD] ! ${datadomeResponse?.reasons[0]}`);
  }
});

// 5. Use it in the registration endpoint of registration controller
@PutMapping(path = "/account")
public ResponseEntity<?> accountUpdate(ServletRequest request, User user) {
  User.Builder userBuilder = co.datadome.fraud.model.User.newBuilder();
        userBuilder.id("user_id")
          .title(Title.MR)
          .email(userform.user.get("email"))
          .description("Some Description / Некоторое описание")
          .displayName("DataDome \uD83E\uDD16")
          .firstName("Data")
          .lastName("Dome")
          .phone("+33978787878")
          .paymentMethodUpdated(true)
          .pictureUrls(new String[]{"https://example.org/image1.png",
                 "https://example.org/image2.png",
                 "https://example.org/image3.png"})
          .externalUrls(new String[]{"https://example.org/external1",
                 "https://example.org/external2",
                 "https://example.org/external3"})
          .address(Address.newBuilder()
                 	 .name("Élysée Palace")
                   .line1("55 Rue du Faubourg Saint-Honoré")
                   .line2("2nd floor")
                   .city("Paris")
                   .countryCode("FR")
                   .country("France")
                   .regionCode("75")
                   .zipCode("75008")
                   .build())
          ;
	DataDomeResponse result = this.dataDomeFraudService.validate(request,
                AccountUpdateEvent.newBuilder(userBuilder.build())
                        .account(userform.user.get("email"))
                        .authentication(
                                Authentication.newBuilder()
                                        .socialProvider(SocialProvider.GOOGLE)
                                        .mode(AuthenticationMode.PASSWORD)
                                        .type(AuthenticationType.SOCIAL)
                                        .build())
                        .session(Session.newBuilder()
                                .id("session_id")
                                .build())
                        .build()
             );

			logger.info(result);
  		if (result.isAllowed()) {
        return new ResponseEntity<>(HttpStatus.OK);
      } else {
        return new ResponseEntity<>(HttpStatus.FORBIDDEN);
      }
}

# Build the user object
user = DataDomeUser.new(
  id: "user_id",
  title: DataDomeTitle::MR,
  email: params[:user][:email],
  description: "Some Description / Некоторое описание",
  display_name: "DataDome 🤖",
  first_name: "Data",
  last_name: "Dome",
  phone: "+33978787878",
  payment_method_updated: true,
  picture_urls: [
        "https://example.org/image1.png",
        "https://example.org/image2.png",
        "https://example.org/image3.png"
      ],
  external_urls: [
        "https://example.org/external1",
        "https://example.org/external2",
        "https://example.org/external3"
      ],
  address: DataDomeAddress.new(
        name: "Élysée Palace",
        line1: "55 Rue du Faubourg Saint-Honoré",
        line2: "2nd floor",
        city: "Paris",
        country_code: "FR",
        region_code: "75",
        zip_code: "75008"
      )
)

# Create authentication object
authentication = DataDomeAuthentication.new(
  social_provider: DataDomeSocialProvider::GOOGLE,
  mode: DataDomeAuthenticationMode::PASSWORD,
  type: DataDomeAuthenticationType::SOCIAL
)

# Create session object
session = DataDomeSession.new(id: "session_id")

# Create the account update event
event = DataDomeAccountUpdateEvent.new(
  account: params[:user][:email],
  user: user,
  authentication: authentication,
  session: session
)

# Build request headers from HTTP request
datadome_headers = DataDomeHeaders.new
datadome_headers.build_from_http_request(request)
datadome_request = DataDomeRequest.new(datadome_headers)

# Validate with DataDome
result = @datadome.validate(request: datadome_request, event: event)

Rails.logger.info("DataDome Response: #{result}")

if result.action == DataDomeResponseAction::ALLOW
  render json: { message: "Account updated successfully" }, status: :ok
else
  render json: { 
        error: "Access denied", 
        action: result.action,
        score: result.score,
        event_id: result.event_id
      }, status: :forbidden
end

[Route("AccountUpdate")]
[HttpPost]
public async Task<IActionResult> AccountUpdate([FromForm] AccountUpdate account)
{
  if (_authenticationService.ValidateAccountUpdate(account))
  {
  
    var session = new Session()
    {
        Id = Guid.NewGuid().ToString("D"),
        CreatedAt = DateTime.UtcNow,
    };

    var user = new User()
    {
        Id = account.Email,
        FirstName = account.Name,
        DisplayName = account.Name,
        Description = "User description",
        PictureUrls = new[] { "https://example.com/profile.jpg" },
        ExternalUrls = new[] { "https://example.com" },
        PaymentMethodUpdated = false,
    };
    
    var AccountUpdateEvent = new AccountUpdateEvent(account.Email, session, user);
    var ddResponse = await _dataDome.Validate(Request, AccountUpdateEvent);

    if (ddResponse.ResponseAction == ResponseAction.Allow)
    {
        _authenticationService.AccountUpdate(account);
        TempData["SuccessMessage"] = "Account updated successfully!";
    }
    else
    {
        // Business logic here
    }
  } else {
    await _dataDome.Collect(
        Request,
        new AccountUpdateEvent(
            account.Email,
            new Session()
            {
                Id = Guid.NewGuid().ToString("D"),
                CreatedAt = DateTime.UtcNow,
            },
            new User()
            {
                Id = account.Email,
                FirstName = account.Name,
                DisplayName = account.DisplayName,
                Description = "User description",
                PictureUrls = new[] { "https://example.com/profile.jpg" },
                ExternalUrls = new[] { "https://example.com" },
                PaymentMethodUpdated = false,
            },
            new Authentication()
            {
                Mode = AuthenticationMode.Password,
                SocialProvider = AuthenticationSocialProvider.Google,
                Type = AuthenticationType.Local
            }
        )
    );
    TempData["ErrorMessage"] = "User not found or incorrect password.";
   }

client, err := dd.NewClient(
  "FRAUD_API_KEY",
  dd.ClientWithEndpoint("account-api.datadome.co"),
  dd.ClientWithTimeout(1500),
)