var request = require("request");

var options = { method: 'POST',
  url: 'https://customer-console-prod.auth.us-west-2.amazoncognito.com/oauth2/token',
  headers: { 'content-type': 'application/x-www-form-urlencoded' },
  body: 'grant_type=client_credentials&client_id=' + client_id + '&client_secret=' + client_secret + '&scope=https://api.getguru.ai/default' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

axios({
    method: 'post',
    url: 'https://api.getguru.ai/videos',
    headers: {
        Authorization: token
    },
    data: {
        filename: 'workout.mp4',
        size: <<video-size-in-bytes>>,
        domain: 'weightlifting',
        activity: 'squat',
        repCount: 12,
        source: 'my-service'
    }
}).then(function (response) {
    const formData = new FormData();
    Object.keys(response.data.fields).forEach((key) => {
        formData.append(key, response.data.fields[key]);
    });
    formData.append("file", video);

    axios.post(
        response.data.url,
        formData,
        {
            headers: { "Content-Type": "multipart/form-data", "Content-Length": <<video-size-in-bytes>> }
        }
    ).catch(function (error) {
        //...
    });
}).catch(function (error) {
    //...
});

//assuming variable 'file' of type Express.Multer.File
axios({
  method: 'post',
  url: 'https://api.getguru.ai/videos',
  headers: {
    Authorization: token
  },
  data: {
    filename: 'workout.mp4',
    size: 1234,
    domain: 'weightlifting',
    activity: 'squat',
    repCount: 12,
    source: 'my-service'
  }
}).then(function (response) {
  const formData = new FormData();
  Object.keys(response.data.fields).forEach((key) => {
    formData.append(key, response.data.fields[key]);
  });
  formData.append("file",  file.buffer , file.originalname);
  let headers = formData.getHeaders()
  formData.getLength(function(err,length){
    headers["content-length"] = length
    axios.post(
      response.data.url,
      formData,
      {
        headers: headers
      }
    ).then(function (response) {
      //...
    }).catch(function (error) {
      //...
    });
  });
}).catch(function (error) {
  //...
});

import os
import requests


def create(video_path, access_token, domain, activity, rep_count = 3):
    return requests.post(
        "https://api.getguru.ai/videos",
        json = {
            "filename": os.path.basename(video_path),
            "size": os.path.getsize(video_path),
            "domain": domain,
            "activity": activity,
            "repCount": rep_count,
        },
        headers = {
            "Content-Type": "application/json",
            "Authorization": access_token
        }
    )


def upload(video_path, create_response):
    json = create_response.json()
    url = json["url"]
    fields = json["fields"]

    with open(video_path, "rb") as file:
        return requests.post(
            url,
            data=fields,
            files={"file": file},
        )

# access_token = ...
video_path = "path/to/video.mp4"
create_response = create(video_path, access_token, "weightlifting", "squat", 1)
upload_response = upload(video_path, create_response)

axios({
    url: 'https://api.getguru.ai/videos/' + videoId,
    headers: {
        Authorization: token
    }
}).then(function (response) {
    //...
});

axios({
    method: 'put',
    url: 'https://api.getguru.ai/videos/' + videoId,
    headers: {
        Authorization: token
    },
    data: {
        repCount: 10,
    }
}).then(function (response) {
    //...
});

axios({
    url: 'https://api.getguru.ai/videos/' + videoId + '/analysis',
    headers: {
        Authorization: token
    }
}).then(function (response) {
    //...
}).catch(function (error) {
    //...
});

{
    "status": "Complete",
    "domain": "weightlifting",
    "activity": "squat",
    "reps": [
        {
            "startTimestampMs": 123,
            "midTimestampMs": 456,
            "endTimestampMs": 789,
            "analyses": [
                {
                    "analysisType": "HIP_KNEE_ANGLE_DEGREES",
                    "analysisScalar": 12.34
                }
            ]
        }
    ]
}

axios({
    url: 'https://api.getguru.ai/videos/' + videoId + '/j2p',
    headers: {
        Authorization: token
    }
}).then(function (response) {
    //...
}).catch(function (error) {
    //...
});

{
  "status": "Complete",
  "resolutionHeight": 1280,
  "resolutionWidth": 720,
  "jointToPoints": {
    "leftAnkle": [{
        "frame_idx": 0,
        "part": "leftAnkle",
        "position": {
          "x": 0.4,
          "y": 0.7
        },
        "score": 0.8,
        "timestamp": 0
      },
      {
        "frame_idx": 4,
        "part": "leftAnkle",
        "position": {
          "x": 0.5,
          "y": 0.75
        },
        "score": 0.86,
        "timestamp": 0.1
      }
    ],
    "leftElbow": [...],
    "leftEye": [...],
    "leftHand": [....],
    "leftHip": [...],
    "leftKnee": [...],
    "leftShoulder": [...],
    "leftWrist": [...],
    "rightElbow": [...],
    "rightEye": [...],
    "rightHand": [....],
    "rightHip": [...],
    "rightKnee": [...],
    "rightShoulder": [...],
    "rightWrist": [...]
  },
  "analysis": {
    "reps": [{
      "startTimestampMs": 123,
      "midTimestampMs": 456,
      "endTimestampMs": 789,
      "analyses": [{
        "analysisType": "HIP_KNEE_ANGLE_DEGREES",
        "analysisScalar": 12.34
      }]
    }]
  }
}

/**
 * @param {Frame} frame - The frame to process
 * @return {*} - The output of processing for this frame.
 */
async function processFrame(frame) {
  return {};
}

class Frame {

  /**
   * Find objects of a specific type within the video.
   *
   * @param {(string|Array.<string>)} objectTypes - The type of the object to find.
   *    Can either be a string, in which case objects of a single type will be found, or an array of strings, in which case multiple object types will be found.
   * @param {boolean} keypoints - Flag indicating whether to include keypoints in the results. Defaults to true.
   * @return {Array.<FrameObject>} A list of FrameObject instances matching the given criteria.
   */
  async findObjects(objectTypes, {keypoints = true} = {});
}

async function processFrame(frame) {
    const objects = await frame.findObjects("person");

    return {people: objects};
}

/**
 * @param {FrameCanvas} frameCanvas - A canvas for the current frame, on which draw operations can be made.
 * @param {*} processResult - The output of the Process function for this frame.
 */
function renderFrame(frameCanvas, processResult) {
}

/**
 * The canvas for a frame, onto which draw operations can be made. This is passed as input to renderFrame().
 */
class FrameCanvas {

  /**
   * Draw a box with the given color around this object's location onto the frame.
   *
   * @param {FrameObject} object - The object around which the box will be drawn.
   * @param {Color} color - The color of the box.
   * @param {number} width - The width of the box's border, in pixels. Defaults to 5.
   * @return {FrameCanvas} This FrameCanvas, that can be used to chain calls.
   */
  drawBoundingBox(object, color, width = 2);

  /**
   * Draws a circle on the canvas.
   *
   * @param {Position} position - The position of the center of the circle.
   * @param {number} radius - The radius of the circle, in pixels.
   * @param {Color} color - The color of the circle.
   * @param {boolean} filled - True if the circle should be filled in. Default true.
   * @param {number} width - If not filled, then this is the width of the circle boundary in pixels. Default 2.
   * @param {number} alpha - Optional, how transparent the circle should be. 0 is invisible, 1 is fully visible. Default is 1.
   */
  drawCircle(position, radius, color, {
    filled = true,
    width = 2,
    alpha = 1.0,
  } = {});

  /**
   * Draws a line between two points on the canvas.
   *
   * @param {Position} from - The position to draw from.
   * @param {Position} to - The position to draw to.
   * @param {Color} color - The color of the line.
   * @param {number} width - Optional, the width of the line in pixels. Default 2.
   * @param {number} alpha - Optional, how transparent the line should be. 0 is invisible, 1 is fully visible. Default is 1.
   */
  drawLine(from, to, color, {
    width = 2,
    alpha = 1.0,
  } = {});

  /**
   * Draws a rectangle on the canvas. The rectangle may have a background color, or be transparent.
   *
   * @param {Position} topLeft - The position of the top-left corner of the rectangle.
   * @param {Position} bottomRight - The position of the bottom-right corner of the rectangle.
   * @param {Color} borderColor - Optional, the color of border of the rectangle. Either this or backgroundColor must be present.
   * @param {Color} backgroundColor - Optional, the color of background of the rectangle. If omitted then the background will be transparent. Either this or backgroundColor must be present.
   * @param {number} width - Optional, the width of the border in pixels. Default 2.
   * @param {number} alpha - Optional, how transparent the rectangle should be. 0 is invisible, 1 is fully visible. Default is 1.
   */
  drawRect(topLeft, bottomRight, {
    borderColor = undefined,
    backgroundColor = undefined,
    width = 2,
    alpha = 1.0,
  } = {});

  /**
   * Draw the skeleton for the given object onto the frame. Note that the object must have its keypoints
   * inferred in order to draw the skeleton.
   *
   * @param {FrameObject} object - The object whose skeleton will be drawn onto the canvas.
   * @param {Color} lineColor - The color of the lines connecting the keypoints in the skeleton.
   * @param {Color} keypointColor - The color of the circles representing the joint keypoints in the skeleton.
   * @param {number} lineWidth - The width, in pixels, of the lines connecting the keypoints. Defaults to 5.
   * @param {number} keypointRadius - The radius, in pixels, of the circles representing the keypoints. Defaults to 5.
   */
  drawSkeleton(object, lineColor, keypointColor, lineWidth = 2, keypointRadius = 5);

  /**
   * Draws text at a specific location on the canvas.
   *
   * @param {string} text - The text to draw.
   * @param {Position} position - The location to draw at. 0,0 is the top-left corner.
   * @param {Color} color - The color of the text.
   * @param {number} maxWidth - Optional, the maximum width of the text in pixels, after which it will wrap. Default 1000.
   * @param {number} fontSize - Optional, the size of the font. Default 24.
   * @param {number} padding - Optional, the amount of padding to apply to the location of the text from its location. Default 0.
   * @param {number} alpha - Optional, how transparent the font should be. 0 is invisible, 1 is fully visible. Default is 1.
   */
  drawText(text, position, color, {
    maxWidth = 1000,
    fontSize = 24,
    padding = 0,
    alpha = 1.0,
  } = {});

function renderFrame(frameCanvas, processResult) {
    const objects = processResult.objects;
    objects.forEach(object => {
        frameCanvas.drawBoundingBox(object, new Color(255, 0, 0));
    });
}

/**
 * @param {Array.<FrameResult>} frameResults - An array of the outputs of calls to the Process function.
 * @return {*} - The analysis result for this video
 */
async function analyzeVideo(frameResults) {
   return {};
}

/**
 * @typedef {Object} FrameResult
 * @property {number} frameIndex - The index of the frame within the video.
 * @property {number} timestampMs - The timestamp of the frame in milliseconds.
 * @property {*} returnValue - The value that was returned from the Process function for this frame.
 */

async function analyzeVideo(frameResults) {
    const frameObjectTypes = frameResults.map((frameResult) => {
        return frameResult.returnValue.objects.map((object) => {
            return object.objectType;
        });
    }).flat();

    return Array.from(new Set(frameObjectTypes));
}

async function analyzeVideo(frameResults) {
    const personId = frameResults.objectIds("person")[0];
    const personFrames = frameResults.objectFrames(personId);
    const reps = MovementAnalyzer.repsByKeypointDistance(personFrames, Keypoint.rightHip, Keypoint.rightAnkle);
    return {
        "reps": reps
    };
}

/**
 * A two-dimensional box, indicating the bounds of something.
 *
 * @typedef {Object} Box
 * @property {Position} top_left - The top-left corner of the box.
 * @property {Position} bottom_right - The bottom-right corner of the box.
 */

/**
 * A colour, represented as an RGB value. Valid values for each are >= 0 and <= 255.
 *
 * @typedef {Object} Color
 * @property {number} r - The amount of red in the color.
 * @property {number} g - The amount of green in the color.
 * @property {number} b - The amount of blue in the color.
 */

/**
 * A single object present within a particular frame or image.
 *
 * @typedef {Object} FrameObject
 * @property {string} objectType - The type of the object.
 * @property {Box} boundary - The bounding box of the object, defining its location within the frame.
 * @property {Object.<string, Position>} keypoints - A map of the name of a keypoint, to its location within the frame.
 */

/**
 * The two-dimensional coordinates indicating the location of something.
 *
 * @typedef {Object} Position
 * @property {number} x - The x coordinate of the position.
 * @property {number} y - The y coordinate of the position.
 * @property {number} confidence - The confidence Guru has of the accuracy of this position. 0.0 implies no confidence, 1.0 implies complete confidence.
 */