/*-
 * ~~~~~~licensing~~~~~~
 * resource-based-storage
 * ==========
 * Copyright (C) 2020 - 2025 EmDev LLC
 * ==========
 * You may not use this file except in accordance with the License Terms of the Copyright
 * Holder located at: https://entaxy.ru/eula . All copyrights, all intellectual property
 * rights to the Software and any copies are the property of the Copyright Holder. Unless
 * it is explicitly allowed the Copyright Holder, the User is prohibited from using the
 * Software for commercial purposes to provide services to third parties.
 * 
 * The Copyright Holder hereby declares that the Software is provided on an "AS IS".
 * Under no circumstances does the Copyright Holder guarantee or promise that the
 * Software provided by him will be suitable or not suitable for the specific purposes
 * of the User, that the Software will meet all commercial and personal subjective
 * expectations of the User, that the Software will work properly, without technical
 * errors, quickly and uninterruptedly.
 * 
 * Under no circumstances shall the Copyright Holder or its Affiliates is not liable
 * to the User for any direct or indirect losses of the User, his expenses or actual
 * damage, including, downtime; loss of bussines; lost profit; lost earnings; loss
 * or damage to data, property, etc.
 * ~~~~~~/licensing~~~~~~
 */
package ru.entaxy.platform.integration.applications.storage.resource.impl.project;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.gson.JsonElement;

import ru.entaxy.esb.resources.EntaxyResource;
import ru.entaxy.platform.base.support.CommonUtils;
import ru.entaxy.platform.base.support.JSONUtils;
import ru.entaxy.platform.core.artifact.ArtifactCoordinates;
import ru.entaxy.platform.integration.applications.descriptor.ApplicationDescriptor;
import ru.entaxy.platform.integration.applications.storage.resource.impl.AbstractResourceComponent;
import ru.entaxy.platform.integration.applications.storage.resource.impl.ResourceContext;

public class BuildComponent extends AbstractResourceComponent<BuildData> {

    private static final Logger LOG = LoggerFactory.getLogger(BuildComponent.class);

    protected EntaxyResource buildResource;
    protected EntaxyResource descriptorResource;

    protected ApplicationDescriptor applicationDescriptor;

    /*
    protected BuildComponent(EntaxyResourceService entaxyResourceService, String parentRootUrl) {
        super(entaxyResourceService);
        this.rootResourceFolderUrl = parentRootUrl.concat("/").concat(".build");
    }
    */

    protected BuildComponent(ResourceContext parentResourceContext) {
        super(parentResourceContext.subcontext(".build"));
    }

    @Override
    protected Class<BuildData> getDataObjectClass() {
        return BuildData.class;
    }

    @Override
    protected String getRootResourceName() {
        return "build-info";
    }

    @Override
    protected BuildData createDataObject() {
        return new BuildData();
    }

    @Override
    public String getComponentKey() {
        return "build";
    }

    @Override
    public void init() {
        super.init();
        descriptorResource = getResource("descriptor.json");
        refresh();
    }

    public void refresh() {
        if (CommonUtils.isValid(dataObject.name)) {
            buildResource = getResource(dataObject.name);
            if (descriptorResource.exists())
                applicationDescriptor = GSON.fromJson(JSONUtils.getJsonRootObject(descriptorResource.getAsString()),
                        ApplicationDescriptor.class);
        }
    }

    public void updateBuild(URL resultUrl, ApplicationDescriptor descriptor, ArtifactCoordinates coordinates) {

        if (isBuildAvailable())
            buildResource.delete();

        dataObject.artifactId = coordinates.getArtifactId();
        dataObject.groupId = coordinates.getGroupId();
        dataObject.version = coordinates.getVersion();
        dataObject.name = coordinates.toAssetName();
        try {
            updateRootResource();
        } catch (Exception e) {
            LOG.error("Error updateing root resource", e);
            return;
        }

        applicationDescriptor = null;

        // (re)init resources
        refresh();

        JsonElement descriptorJe = GSON.toJsonTree(descriptor, ApplicationDescriptor.class);
        String descriptorJson = descriptorJe.toString();
        try (InputStream is = new ByteArrayInputStream(descriptorJson.getBytes())) {
            descriptorResource.save(is);
        } catch (IOException e) {
            LOG.error("Error saving resource [" + descriptorResource.getURL() + "]", e);
        }

        try (InputStream is = resultUrl.openStream()) {
            buildResource.save(is);
        } catch (IOException e) {
            LOG.error("Error saving resource [" + descriptorResource.getURL() + "]", e);
        }

        applicationDescriptor = GSON.fromJson(descriptorJe,
                ApplicationDescriptor.class);

    }

    public boolean isBuildAvailable() {
        return buildResource != null && buildResource.exists();
    }

    public EntaxyResource getBuildResource() {
        return buildResource;
    }

    public ApplicationDescriptor getApplicationDescriptor() {
        return applicationDescriptor;
    }

}
