var path, method, request, domain, bublDomain, token, proxyUrl, env string

func init() {
   const (
   	pathValue     = "/"
   	pathUsage     = "relative api path"
   	methodValue   = "GET"
   	methodUsage   = "method for api"
   	requestValue  = ""
   	requestUsage  = "api request - base64 encoded json string"
   	domainValue   = ""
   	domainUsage   = "instance domain of bubl"
   	tokenValue    = "testtoken"
   	tokenUsage    = "access token for connect client authentication"
   	proxyUrlValue = ""
   	proxyUrlUsage = "proxy url to access outside urls"
   	envValue      = "dev"
   	envUsage      = "environment"
   )
   flag.StringVar(&path, "path", pathValue, pathUsage)
   flag.StringVar(&path, "p", pathValue, pathUsage+" (shorthand)")
   flag.StringVar(&method, "method", methodValue, methodUsage)
   flag.StringVar(&method, "m", methodValue, methodUsage+" (shorthand)")
   flag.StringVar(&request, "request", requestValue, requestUsage)
   flag.StringVar(&request, "r", requestValue, requestUsage+" (shorthand)")
   flag.StringVar(&domain, "domain", domainValue, domainUsage)
   flag.StringVar(&domain, "d", domainValue, domainUsage+" (shorthand)")
   flag.StringVar(&token, "token", tokenValue, tokenUsage)
   flag.StringVar(&token, "t", tokenValue, tokenUsage+" (shorthand)")
   flag.StringVar(&proxyUrl, "proxy", proxyUrlValue, proxyUrlUsage)
   flag.StringVar(&proxyUrl, "pr", proxyUrlValue, proxyUrlUsage+" (shorthand)")
   flag.StringVar(&env, "env", envValue, envUsage)
   flag.StringVar(&env, "e", envValue, envUsage+" (shorthand)")
   flag.Parse()
}

use clap::{Arg, Command};
use base64::{Engine as _, engine::general_purpose};
use std::str;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Person {
  name: String,
}

#[derive(Serialize, Deserialize)]
struct Response {
  answer: String,
}

fn main() {
   let matches = Command::new("Bubl Cloud Hello World")
       .version("0.1.0")
       .author("Niek Temme <Niek@bubl.cloud>")
       .about("example rust back-end service")
       .arg(Arg::new("path")
                .short('p')
                .help("the relative path of the api"))
       .arg(Arg::new("method")
                .short('m')
                .help("the method, for example GET"))
       .arg(Arg::new("request_body")
                .short('r')
                .help("the request body"))
       .get_matches();

   let default_method = "GET".to_string();
   let default_path = "/".to_string();
   let method: &String = matches.get_one::<String>("method").unwrap_or(&default_method);
   let path: &String = matches.get_one::<String>("path").unwrap_or(&default_path);
   let request_body: &String = matches.get_one::<String>("request_body").unwrap();
  

   // decode the request body
   let decoded = &general_purpose::STANDARD.decode(request_body).unwrap();
   let decoded_slice = &decoded.as_slice();
   let request_body_decoded: &str = str::from_utf8(&decoded_slice).unwrap();
   let request_body_decoded_string = request_body_decoded.to_string();
}

   // check if path is special
   switch c.Path {
   case "/install":
   	err := s.connect.CreateTable(context.Background(), &connect.ServiceDataTableRequest{
   		TableName: servicetableName,
   	})
   	if err != nil {
   		sendResultWithStatus(http.StatusInternalServerError, Errors{Errs: []string{err.Error()}}, true)
   		return
   	}
   	sendResponse(http.StatusOK, nil)
   	return
   case "/update":
   	sendResponse(http.StatusOK, nil)
   	return
   }
   // decode request
   var decodedRequest string
   if c.Request != "" {
   	dr, err := base64.StdEncoding.DecodeString(c.Request)
   	if err != nil {
   		sendResponse(http.StatusInternalServerError, errResponse(err))
   		return
   	}
   	decodedRequest = string(dr)
   }
   // check method
   switch c.Method {
   case "GET":
   	s.getRequests(c.Path, decodedRequest)
   case "POST":
   	s.postRequests(c.Path, decodedRequest)
   case "PUT":
   	s.putRequests(c.Path, decodedRequest)
   case "DELETE":
   	s.deleteRequests(c.Path, decodedRequest)
   default:
   	sendResponse(http.StatusMethodNotAllowed, nil)
   }

func (s *Service) getRequests(path, req string) {
   switch {
   case strings.Contains(path, "/v1/data/"):
   	key := strings.TrimPrefix(path, "/v1/data/")
   	s.GetData(key)
   case path == "/v1/listdata":
   	s.ListData()
   case path == "/v1/environment":
   	s.GetEnvironment()
   default:
   	sendResponse(http.StatusNotFound, nil)
   }
}

func (s *Service) postRequests(path, req string) {
   switch {
   case path == "/v1/data":
   	s.CreateNewData(req)
   default:
   	sendResponse(http.StatusNotFound, nil)
   }
}

func (s *Service) putRequests(path, req string) {
   switch {
   case strings.Contains(path, "/v1/data/"):
   	key := strings.TrimPrefix(path, "/v1/data/")
   	s.UpdateData(key, req)
   default:
   	sendResponse(http.StatusNotFound, nil)
   }
}

func (s *Service) deleteRequests(path, req string) {
   switch {
   case strings.Contains(path, "/v1/data/"):
   	key := strings.TrimPrefix(path, "/v1/data/")
   	s.RemoveData(key)
   default:
   	sendResponse(http.StatusNotFound, nil)
   }
}

fn main() {
// main function above extended
    match method.as_str() {
        // Match a single value
        "POST" => post_requests(path, &request_body_decoded_string),
        _ => println!("Ain't special"),
        // TODO ^ Try commenting out this catch-all arm
    }
}

fn post_requests(path: &String, request_body: &String) {
    match path.as_str() {
        // Match a single value
        "/hello" => hello_answer(request_body),
        _ => println!("Ain't special"),
        // TODO ^ Try commenting out this catch-all arm
    }
}

fn hello_answer(request_body: &String) {

    let strbody = request_body.as_str();
    let p: Person = serde_json::from_str(&strbody).unwrap();
    let start = "Nice to meet you";
    let resp = start.to_string() + " " + &p.name;
    let response = Response {
        answer: resp
    };
    let j = serde_json::to_string(&response).unwrap();
    let j_bytes = j.as_bytes();
    let encoded: String = general_purpose::STANDARD.encode(j_bytes);
    println!("{}", encoded);
}

func sendResponse(httpStatus int, body json.RawMessage) {
   resp, _ := json.Marshal(&Response{
   	ApplicationName:    applicationName,
   	ApplicationVersion: applicationVersion,
   	HTTPStatus:         httpStatus,
   	Body:               body,
   })
   response(string(resp))
}
func response(resp string) {
   response := `{ "response" : ` + resp + `}`
   fmt.Println(base64.StdEncoding.EncodeToString([]byte(response)))
}

type ServiceCustomTokenRequest struct {
   UserDescription               string                      `json:"userDescription"`
   AllowedServiceEndpoints       map[string]string           `json:"allowedServiceEndpoints"`
   AllowedUnstructuredDataCommon map[string]CommondataParams `json:"allowedUnstructuredDataCommon"`
   EndDate                       int64                       `json:"endDate"`
}
type CommondataParams struct {
   Level  string `json:"level" binding:"required"`
   Method string `json:"method" binding:"required"`
}

type ServiceCustomToken struct {
   AccessToken string `json:"accessToken"`
}

type InitPaymentRequest struct {
   Amount      float64 `json:"amount,omitempty"`
   Currency    string  `json:"currency,omitempty"`
   Description string  `json:"description,omitempty"`
   Forward     string  `json:"forward,omitempty"`
   Language    string  `json:"language,omitempty"`
}

type InitPaymentResponse struct {
   BublPaymentUUID string  `json:"bublPaymentUuid"`
   Amount          float64 `json:"amount"`
   Currency        string  `json:"currency"`
   Language        string  `json:"language"`
}

type PaymentStatus struct {
   BublPaymentUUID string `json:"bublPaymentUuid"`
   Status          int    `json:"status"`
   StatusInfo      string `json:"statusInfo"`
}

  package rest

import (
   "bytes"
   "context"
   "encoding/json"
   "fmt"
   "io"

   "net/http"
)

const authHeader = "Authorization"
const tokenType = "Bearer"

// Client ...
type Client struct {
   client      *http.Client
   server      string
   serverToken string
   readAll     func(io.Reader) ([]byte, error)
}

// NewConnectService ...
func NewConnectService(server string, token string) *Client {
   return &Client{
   	server:      server,
   	serverToken: token,
   	client: &http.Client{
   		Transport: &http.Transport{
   			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
   		},
   	},
   	readAll: io.ReadAll,
   }
}

// CreateTable ...
func (c *Client) CreateTable(ctx context.Context, sdtreq *connect.ServiceDataTableRequest) error {
   return c.doRequest(ctx, http.MethodPut, "/servicedata/table", sdtreq, nil)
}

func (c *Client) DropTable(ctx context.Context, sdtreq *connect.ServiceDataTableRequest) error {
   return c.doRequest(ctx, http.MethodDelete, "/servicedata/table", sdtreq, nil)
}

// AddServiceData adds data to service data or allowed common data
func (c *Client) AddServiceData(ctx context.Context, tableName string, sdreq *connect.ServiceDataRequest) error {
   return c.doRequest(ctx, http.MethodPost, "/servicedata/data/"+tableName, sdreq, nil)
}

// RemoveServiceData deletes data from service data or allowed common data
func (c *Client) RemoveServiceData(ctx context.Context, tableName string, sdreq *connect.ServiceDataRequest) error {
   return c.doRequest(ctx, http.MethodDelete, "/servicedata/data/"+tableName, sdreq, nil)
}

// GetServiceData gets data from service data or allowed common data
func (c *Client) GetServiceData(ctx context.Context, tableName string, sdreq *connect.ServiceDataRequest) (*connect.ServiceData, error) {
   res := &connect.ServiceData{}
   return res, c.doRequest(ctx, http.MethodGet, "/servicedata/data/"+tableName, sdreq, res)
}

// ListServiceData gets list of data from service data or allowed common data
func (c *Client) ListServiceData(ctx context.Context, tableName string, sdreq *connect.ServiceDataRequest) ([]*connect.ServiceData, error) {
   var res []*connect.ServiceData
   return res, c.doRequest(ctx, http.MethodGet, "/servicedata/data/"+tableName, sdreq, &res)
}

// GetCustomToken gets the custom token
func (c *Client) GetCustomToken(ctx context.Context, req *connect.ServiceCustomTokenRequest) (*connect.ServiceCustomToken, error) {
   resp := &connect.ServiceCustomToken{}
   return resp, c.doRequest(ctx, http.MethodPut, "/controller/servicetoken", req, resp)
}

// SendEmail sends an email to user
func (c *Client) SendEmail(ctx context.Context, req *connect.Email) error {
   return c.doRequest(ctx, http.MethodPost, "/email/sendemail", req, nil)
}

// InitPayment initiates a payment
func (c *Client) InitPayment(ctx context.Context, req *connect.InitPaymentRequest) (*connect.InitPaymentResponse, error) {
   resp := &connect.InitPaymentResponse{}
   return resp, c.doRequest(ctx, http.MethodPost, "/payments/initpayment", req, resp)
}

// GetPaymentStatus gives the status of a payment id
func (c *Client) GetPaymentStatus(ctx context.Context, paymentuuid string) (*connect.PaymentStatus, error) {
   resp := &connect.PaymentStatus{}
   return resp, c.doRequest(ctx, http.MethodGet, "/payments/status?bublPaymentUuid="+paymentuuid, nil, resp)
}

func (c *Client) doRequest(ctx context.Context, method string, path string, body, response interface{}) error {
   var bodyReader io.Reader
   if body != nil {
   	reqBody, err := json.Marshal(body)
   	if err != nil {
   		return err
   	}
   	bodyReader = bytes.NewBuffer(reqBody)
   }
   req, err := http.NewRequest(method, c.server+path, bodyReader)
   if err != nil {
   	return err
   }
   req.Header.Add("Content-Type", "application/json")
   req.Header.Add(authHeader, tokenType+" "+c.serverToken)
   resp, err := c.client.Do(req)
   if err != nil {
   	return err
   }
   defer resp.Body.Close()
   switch resp.StatusCode {
   case http.StatusOK, http.StatusCreated:
   case http.StatusNoContent:
   	return connect.ErrNoData
   default:
   	return fmt.Errorf("cannot reach connect service %s", resp.Status)
   }

   if response == nil {
   	return nil
   }

   data, err := c.readAll(resp.Body)
   if err != nil {
   	return err
   }
   if err := json.Unmarshal(data, response); err != nil {
   	return err
   }

   return nil
}

# some code
print("This line will be printed.")

const (
   authHeader      = "Authorization"
   tokenType       = "Bearer"
   ProxyAuthHeader = "Proxy-Authorization"
)
// Client ...
type Client struct {
   client  *http.Client
   readAll func(io.Reader) ([]byte, error)
}

// NewPlatformService ...
func NewPlatformService(proxyurl, token string) (*Client, error) {
   proxyUrl, err := url.Parse(proxyurl)
   if err != nil {
   	return nil, err
   }
   cacerts, err := os.ReadFile("/etc/ssl/cert.pem")
   if err != nil {
   	return nil, err
   }
   pool := x509.NewCertPool()
   if !pool.AppendCertsFromPEM(cacerts) {
   	return nil, err
   }
   return &Client{
   	client: &http.Client{
   		Transport: &http.Transport{
   			Proxy: http.ProxyURL(&url.URL{
   				Scheme: proxyUrl.Scheme,
   				User:   url.UserPassword("", token),
   				Host:   proxyUrl.Host,
   			}),
   			TLSClientConfig: &tls.Config{
   				RootCAs: pool,
   			},
   		},
   	},
   	readAll: io.ReadAll,
   }, nil
}