/*
 * Copyright 2017 Graz University of Technology EAAF-Core Components has been developed in a
 * cooperation between EGIZ, A-SIT Plus, A-SIT, and Graz University of Technology.
 *
 * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by the European
 * Commission - subsequent versions of the EUPL (the "Licence"); You may not use this work except in
 * compliance with the Licence. You may obtain a copy of the Licence at:
 * https://joinup.ec.europa.eu/news/understanding-eupl-v12
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the Licence
 * is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the Licence for the specific language governing permissions and limitations under
 * the Licence.
 *
 * This product combines work with different licenses. See the "NOTICE" text file for details on the
 * various modules and licenses. The "NOTICE" text file is part of the distribution. Any derivative
 * works that you distribute must include a readable copy of the "NOTICE" text file.
 */

package at.gv.egiz.eaaf.core.impl.utils;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class FileUtils {
  private static final Logger log = LoggerFactory.getLogger(FileUtils.class);

  /**
   * Reads a file, given by URL, into a byte array.
   *
   * @param urlString file URL
   * @return file content
   * @throws IOException on any exception thrown
   */
  public static byte[] readUrl(final String urlString) throws IOException {
    final URL url = new URL(urlString);
    final InputStream in = new BufferedInputStream(url.openStream());
    final byte[] content = StreamUtils.readStream(in);
    in.close();
    return content;
  }

  /**
   * Reads a file from a resource.
   *
   * @param name resource name
   * @return file content as a byte array
   * @throws IOException on any exception thrown
   */
  public static byte[] readResource(final String name) throws IOException {
    final ClassLoader cl = FileUtils.class.getClassLoader();
    final BufferedInputStream in = new BufferedInputStream(cl.getResourceAsStream(name));
    final byte[] content = StreamUtils.readStream(in);
    in.close();
    return content;
  }

  /**
   * Reads a file from a resource.
   *
   * @param name     filename
   * @param encoding character encoding
   * @return file content
   * @throws IOException on any exception thrown
   */
  public static String readResource(final String name, final String encoding) throws IOException {
    final byte[] content = readResource(name);
    return new String(content, encoding);
  }

  /**
   * Returns the absolute URL of a given url which is relative to the parameter
   * root.
   *
   * @param url  Filepath
   * @param root configuration root context
   * @return absolut filepath
   * @throws MalformedURLException In case of a filepath error
   */
  public static String makeAbsoluteUrl(final String url, final URI root)
      throws MalformedURLException {
    if (root != null) {
      return makeAbsoluteUrl(url, root.toURL().toString());
    } else {
      return makeAbsoluteUrl(url, StringUtils.EMPTY);
    }

  }

  /**
   * Returns the absolute URL of a given url which is relative to the parameter
   * root.
   *
   * @param url  Filepath
   * @param root configuration root context
   * @return absolut filepath
   */
  public static String makeAbsoluteUrl(final String url, String root) {
    // if url is relative to rootConfigFileDirName make it absolute

    log.trace("Making AbsoluteURL URL: " + url + " Root-Path: " + root);

    if (StringUtils.isEmpty(root)) {
      root = null;
    }

    File keyFile;
    String newUrl = url;

    if (null == url) {
      return null;
    }

    if (url.startsWith("http:") || url.startsWith("https:") || url.startsWith("file:")
        || url.startsWith("ftp:") || url.startsWith("classpath:")) {
      return url;

    } else {
      // check if absolute - if not make it absolute
      keyFile = new File(url);
      if (!keyFile.isAbsolute()) {
        keyFile = new File(root, url);

        if (keyFile.toString().startsWith("file:")) {
          newUrl = keyFile.toString();
        } else {
          newUrl = keyFile.toURI().toString();
        }

      }
      return newUrl;
    }
  }

  private static void copy(final InputStream fis, final OutputStream fos) {
    try {
      final byte[] buffer = new byte[0xFFFF];
      for (int len; (len = fis.read(buffer)) != -1;) {
        fos.write(buffer, 0, len);
      }
    } catch (final IOException e) {
      System.err.println(e);

    }
  }

  /**
   * Copy file from source to destination.
   *
   * @param src  File source
   * @param dest file destination
   */
  public static void copyFile(final File src, final File dest) {
    InputStream fis = null;
    OutputStream fos = null;

    try {
      fis = new FileInputStream(src);
      fos = new FileOutputStream(src);
      copy(fis, fos);

    } catch (final IOException e) {
      e.printStackTrace();

    } finally {
      if (fis != null) {
        try {
          fis.close();
        } catch (final IOException e) {
          e.printStackTrace();
        }
      }
      if (fos != null) {
        try {
          fos.close();
        } catch (final IOException e) {
          e.printStackTrace();
        }
      }
    }
  }

}