#ifdef ENABLE_MDKREPO

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "pool.h"
#include "repo.h"
#include "chksum.h"
#include "repo_mdk.h"
#include "solv_xfopen.h"

#include "repoinfo.h"
#include "repoinfo_cache.h"
#include "repoinfo_download.h"
#include "repoinfo_type_mdk.h"

static int
mdk_find(const char *md5sums, const char *what, unsigned char *chksum)
{
  const char *sp, *ep;
  int wl = strlen(what);
  for (sp = md5sums; (ep = strchr(sp, '\n')) != 0; sp = ep + 1)
    {
      int l = ep - sp;
      if (l <= 34)
	continue;
      if (sp[32] != ' ' || sp[33] != ' ')
	continue;
      if (wl != l - 34 || strncmp(what, sp + 34, wl) != 0)
	continue;
      if (solv_hex2bin(&sp, chksum, 16) != 16)
	continue;
      return 1;
    }
  return 0;
}

static char *
slurp(FILE *fp)
{
  int l, ll;
  char *buf = 0;
  int bufl = 0;

  for (l = 0; ; l += ll)
    {
      if (bufl - l < 4096)
        {
          bufl += 4096;
          buf = solv_realloc(buf, bufl);
        }
      ll = fread(buf + l, 1, bufl - l, fp);
      if (ll < 0)
        {
          buf = solv_free(buf);
          l = 0;
          break;
        }
      if (ll == 0)
        {
          buf[l] = 0;
          break;
        }
    }
  return buf;
}

int
mdk_load_ext(Repo *repo, Repodata *data)
{
  struct repoinfo *cinfo = repo->appdata;
  const char *type, *ext, *filename;
  const unsigned char *filechksum;
  Id filechksumtype;
  int r = 0;
  FILE *fp;

  type = repodata_lookup_str(data, SOLVID_META, REPOSITORY_REPOMD_TYPE);
  if (strcmp(type, "filelists") != 0)
    return 0;
  ext = "FL";
  printf("[%s:%s", repo->name, ext);
  if (usecachedrepo(cinfo, ext, 0))
    {
      printf(" cached]\n"); fflush(stdout);
      return 1;
    }
  printf(" fetching]\n"); fflush(stdout);
  filename = repodata_lookup_str(data, SOLVID_META, REPOSITORY_REPOMD_LOCATION);
  filechksumtype = 0;
  filechksum = repodata_lookup_bin_checksum(data, SOLVID_META, REPOSITORY_REPOMD_CHECKSUM, &filechksumtype);
  if ((fp = curlfopen(cinfo, filename, 1, filechksum, filechksumtype, 0)) == 0)
    return 0;
  r = repo_add_mdk_info(repo, fp, REPO_USE_LOADING|REPO_EXTEND_SOLVABLES|REPO_LOCALPOOL);
  fclose(fp);
  if (r)
    {
      printf("%s\n", pool_errstr(repo->pool));
      return 0;
    }
  writecachedrepo(cinfo, ext, data);
  return 1;
}

static void
mdk_add_ext(Repo *repo, Repodata *data, const char *what, const char *ext, const char *filename, Id chksumtype, const unsigned char *chksum)
{
  Id handle = repodata_new_handle(data);
  /* we mis-use the repomd ids here... need something generic in the future */
  repodata_set_poolstr(data, handle, REPOSITORY_REPOMD_TYPE, what);
  repodata_set_str(data, handle, REPOSITORY_REPOMD_LOCATION, filename);
  repodata_set_bin_checksum(data, handle, REPOSITORY_REPOMD_CHECKSUM, chksumtype, chksum);
  add_ext_keys(data, handle, ext);
  repodata_add_flexarray(data, SOLVID_META, REPOSITORY_EXTERNAL, handle);
}

int
mdk_load(struct repoinfo *cinfo, Pool **sigpoolp)
{
  Repo *repo = cinfo->repo;
  Pool *pool = repo->pool;
  Repodata *data;
  const char *compression;
  FILE *fp, *cfp;
  char *md5sums;
  unsigned char probe[5];
  unsigned char md5[16];

  printf("mdk repo '%s':", cinfo->alias);
  fflush(stdout);
  if ((fp = curlfopen(cinfo, "media_info/MD5SUM", 0, 0, 0, 0)) == 0)
    {
      printf(" no media_info/MD5SUM file\n");
      cinfo->incomplete = 1;
      return 0;
    }
  calc_cookie_fp(fp, REPOKEY_TYPE_SHA256, cinfo->cookie);
  cinfo->cookieset = 1;
  if (usecachedrepo(cinfo, 0, 1))
    {
      printf(" cached\n");
      fclose(fp);
      return 1;
    }
  md5sums = slurp(fp);
  fclose(fp);
  printf(" fetching\n");
  if (!mdk_find(md5sums, "synthesis.hdlist.cz", md5))
    {
      solv_free(md5sums);
      cinfo->incomplete = 1;
      return 0;	/* hopeless */
    }
  if ((fp = curlfopen(cinfo, "media_info/synthesis.hdlist.cz", 0, md5, REPOKEY_TYPE_MD5, 1)) == 0)
    {
      solv_free(md5sums);
      cinfo->incomplete = 1;
      return 0;	/* hopeless */
    }
  /* probe compression */
  if (fread(probe, 5, 1, fp) != 1)
    {
      fclose(fp);
      solv_free(md5sums);
      cinfo->incomplete = 1;
      return 0;	/* hopeless */
    }
  if (probe[0] == 0xfd && memcmp(probe + 1, "7zXZ", 4) == 0)
    compression = "synthesis.hdlist.xz";
  else
    compression = "synthesis.hdlist.gz";
  lseek(fileno(fp), 0, SEEK_SET);
  cfp = solv_xfopen_fd(compression, dup(fileno(fp)), "r");
  fclose(fp);
  fp = cfp;
  if (!fp)
    {
      solv_free(md5sums);
      cinfo->incomplete = 1;
      return 0;	/* hopeless */
    }
  if (repo_add_mdk(repo, fp, REPO_NO_INTERNALIZE))
    {
      printf("synthesis.hdlist.cz: %s\n", pool_errstr(pool));
      fclose(fp);
      solv_free(md5sums);
      cinfo->incomplete = 1;
      return 0;	/* hopeless */
    }
  fclose(fp);
  /* add info, could do this on demand, but always having the summary is nice */
  if (mdk_find(md5sums, "info.xml.lzma", md5))
    {
      if ((fp = curlfopen(cinfo, "media_info/info.xml.lzma", 1, md5, REPOKEY_TYPE_MD5, 1)) != 0)
	{
	  if (repo_add_mdk_info(repo, fp, REPO_NO_INTERNALIZE|REPO_REUSE_REPODATA|REPO_EXTEND_SOLVABLES))
	    {
	      printf("info.xml.lzma: %s\n", pool_errstr(pool));
	      cinfo->incomplete = 1;
	    }
	  fclose(fp);
	}
    }
  repo_internalize(repo);
  data = repo_add_repodata(repo, 0);
  /* setup on-demand loading of filelist data */
  if (mdk_find(md5sums, "files.xml.lzma", md5))
    {
      repodata_extend_block(data, repo->start, repo->end - repo->start);
      mdk_add_ext(repo, data, "filelists", "FL", "media_info/files.xml.lzma", REPOKEY_TYPE_MD5, md5);
    }
  solv_free(md5sums);
  repodata_internalize(data);
  writecachedrepo(cinfo, 0, 0);
  repodata_create_stubs(repo_last_repodata(repo));
  return 1;
}

#endif