export let getToken = function (): TokenStateSchema | null {
  let user = Cookies.get('user');
  let token = Cookies.get('token');
  if (user !== undefined && token !== undefined) {
    return {token: token, user: user};
  }
  return null;
};

export function loadSessionState() {
    return {
        type: LOAD_SESSION_STATE,
        payload: {
            gitHubAuthToken: cookies.get("gitHubAuthToken"),
            gitHubAuthState: cookies.get("gitHubAuthState"),
        },
    };
}

  setVisitorInfo() {
    const visitorId = this._config.visitorId
      || Cookies.get(VISITOR_COOKIE_KEY)
      || uuid.v1();
    const sessionId = this._config.sessionId
      || Cookies.get(SESSION_COOKIE_KEY)
      || uuid.v1();

    this.setVisitor(visitorId, sessionId);
  }

 /**
  * Applies the theme to the website
  */
 public applyTheme() {
     if (Cookie.get('theme') == 'dark') {
         this.setDarkTheme();
     } else {
         this.setLightTheme();
     }
 }

export const createAJAXSettings = (
  serverConfig: ServerConfig,
  uri = "/",
  opts: Partial<AjaxRequest> = {}
): AjaxRequest => {
  const baseURL = normalizeBaseURL(serverConfig.endpoint || serverConfig.url);
  const url = `${baseURL}${uri}`;
  // Use the server config provided token if available before trying cookies
  const xsrfToken = serverConfig.xsrfToken || Cookies.get("_xsrf");
  const headers = {
    "X-XSRFToken": xsrfToken,
    Authorization: `token ${serverConfig.token ? serverConfig.token : ""}`
  };

  // Merge in our typical settings for responseType, allow setting additional
  // options like the method
  const settings = {
    url,
    responseType: "json",
    createXHR: () => new XMLHttpRequest(),
    ...serverConfig,
    ...opts,
    // Make sure we merge in the auth headers with user given headers
    headers: { ...headers, ...opts.headers }
  };
  delete settings.endpoint;
  return settings;
};

export function fetchGitHubRepos(org, page = 1, username) {
    const token = cookies.get("gitHubAuthToken");
    const urlPath = username ? `users/${username}/repos` : `orgs/${org}/repos`;

    return dispatch => {
        if (page === 1) {
            dispatch(setGitHubReposLoadingFlag(true));
        }

        fetch(`https://api.github.com/${urlPath}?access_token=${token}&per_page=100&page=${page}`).then(response => {
            const links = parseLinkHeader(response.headers.get("Link"));

            // When we get the first page, clear everything out
            if (page === 1) { dispatch(resetGitHubRepos()); }

            if (links && links.next && links.next.page) {
                dispatch(fetchGitHubRepos(org, links.next.page, username));
            } else {
                dispatch(setGitHubReposLoadingFlag(false));
            }

            response.json().then(data => dispatch(populateGitHubRepos(data)));
        });
    };
}

    score_update(add_to_score:number) {
        this.max_score = parseInt(Cookies.get('max_score'), 10) || 0;

        this.score += add_to_score;
        if (this.score > this.max_score) {
            Cookies.set('max_score', this.max_score);
        }
    }

  public static addToBasket(item) {
    const basket = JSON.parse(Cookies.get('basket'));
    const {id} = basket;
    const uri = `${ITEM_URI}/${id}/order_items`;
    const data = {size: item.size, shoeModelId: item.id};

    APIUtils.post(uri, data)
      .then(BasketServerActions.receiveBasketItemPush);
  }

export function setGitHubAuthState() {
    let payload = cookies.get("gitHubAuthState") || uuid();
    setCookie("gitHubAuthState", payload);

    return {
        type: SET_GITHUB_AUTH_STATE,
        payload
    };
}

    constructor(x_size, y_size) {
        this.array = [];
        this.x_size = x_size;
        this.y_size = y_size;
        this.score = 0;
        this.max_score = parseInt(Cookies.get('max_score'), 10) || 0;

        for (let i = 0; i < this.x_size * this.y_size; i++) {
            this.array[i] = null;
        }
    }