package ctbrec.sites.showup;

import static ctbrec.Model.State.*;
import static ctbrec.io.HttpConstants.*;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.json.JSONArray;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.Objects;

import ctbrec.Config;
import ctbrec.Model;
import ctbrec.ModelNotFoundException;
import ctbrec.UnknownModel;
import ctbrec.io.HttpClient;
import ctbrec.io.HttpException;
import ctbrec.sites.AbstractSite;
import okhttp3.Request;
import okhttp3.Response;

public class Showup extends AbstractSite {

    private static final transient Logger LOG = LoggerFactory.getLogger(Showup.class);
    private ShowupHttpClient httpClient;

    @Override
    public String getName() {
        return "Showup.tv";
    }

    @Override
    public String getBaseUrl() {
        return "https://showup.tv";
    }

    @Override
    public String getAffiliateLink() {
        return getBaseUrl();
    }

    @Override
    public Model createModel(String name) {
        try {
            for (Model m : getModelList()) {
                if (Objects.equal(m.getName(), name)) {
                    return m;
                }
            }
        } catch (IOException e) {
            throw new ModelNotFoundException(name, e);
        }
        throw new ModelNotFoundException(name);
    }

    public List<Model> getModelList() throws IOException {
        String url = getBaseUrl() + "/site/get_stream_list/big";
        Request req = new Request.Builder()
                .url(url)
                .header(USER_AGENT, Config.getInstance().getSettings().httpUserAgent)
                .build();

        try (Response response = getHttpClient().execute(req)) {
            if (response.isSuccessful()) {
                String body = response.body().string();
                LOG.trace(body);
                JSONObject json = new JSONObject(body);
                List<Model> models = new ArrayList<>();
                JSONArray list = json.getJSONArray("list");
                for (int i = 0; i < list.length(); i++) {
                    JSONObject entry = list.getJSONObject(i);
                    ShowupModel model = new ShowupModel();
                    model.setUid(entry.getLong("uid"));
                    model.setPreview(getBaseUrl() + "/files/" + entry.optString("big_img") + ".jpg");
                    model.setDescription(entry.optString("description"));
                    model.setName(entry.optString("username"));
                    model.setUrl(getBaseUrl() + '/' + model.getName());
                    if(entry.optInt("is_group") == 1) {
                        model.setOnlineState(GROUP);
                    } else if(entry.optInt("is_prv") == 1) {
                        model.setOnlineState(PRIVATE);
                    } else {
                        model.setOnlineState(ONLINE);
                    }
                    model.setStreamId(entry.optString("stream_id"));
                    model.setStreamTranscoderAddr(entry.optString("stream_transcoder_addr"));
                    model.setSite(this);
                    models.add(model);
                }
                return models;
            } else {
                throw new HttpException(response.code(), response.message());
            }
        }
    }

    @Override
    public Double getTokenBalance() throws IOException {
        return 0d;
    }

    @Override
    public String getBuyTokensLink() {
        return getBaseUrl();
    }

    @Override
    public boolean login() throws IOException {
        return false;
    }

    @Override
    public HttpClient getHttpClient() {
        if (httpClient == null) {
            httpClient = new ShowupHttpClient();
        }
        return httpClient;
    }

    @Override
    public void init() throws IOException {
        // noop
    }

    @Override
    public void shutdown() {
        if (httpClient != null) {
            httpClient.shutdown();
        }
    }

    @Override
    public boolean supportsTips() {
        return false;
    }

    @Override
    public boolean supportsFollow() {
        return false;
    }

    @Override
    public boolean isSiteForModel(Model m) {
        return m instanceof ShowupModel;
    }

    @Override
    public boolean credentialsAvailable() {
        return false;
    }

    @Override
    public Model createModelFromUrl(String url) {
        Matcher matcher = Pattern.compile(getBaseUrl() + "(?:/profile)?/(.*)").matcher(url);
        if (matcher.find()) {
            return createModel(matcher.group(1));
        } else {
            return new UnknownModel();
        }
    }

}