package com.fr.plugin.db.redis.core;

import com.fr.config.holder.Conf;
import com.fr.config.holder.factory.Holders;
import com.fr.data.impl.AbstractDatabaseConnection;
import com.fr.data.impl.Connection;
import com.fr.general.Inter;
import com.fr.locale.InterProviderFactory;
import com.fr.security.SecurityToolbox;
import com.fr.stable.ArrayUtils;
import com.fr.stable.StableUtils;
import com.fr.stable.StringUtils;
import com.fr.stable.xml.XMLPrintWriter;
import com.fr.stable.xml.XMLableReader;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Set;

public class RedisDatabaseConnection extends AbstractDatabaseConnection {

    private static final int DEFAULT_REDIS_PORT = 6379;

    private Conf<String> host = Holders.simple(StringUtils.EMPTY);
    private Conf<Integer> port = Holders.simple(DEFAULT_REDIS_PORT);
    private Conf<String> password = Holders.simple(StringUtils.EMPTY);

    public RedisDatabaseConnection() {

    }

    public String getHost() {
        return host.get();
    }

    public void setHost(String host) {
        this.host.set(host);
    }

    public int getPort() {
        return port.get();
    }

    public void setPort(int port) {
        this.port.set(port);
    }

    public String getPassword() {
        return password.get();
    }

    public void setPassword(String password) {
        this.password.set(password);
    }



    @Override
    public void testConnection() throws Exception {
        Jedis client = createRedisClient();
        try {
            String text = client.ping();
            if (!"pong".equalsIgnoreCase(text)) {
                throw new Exception(text);
            }
        } finally {
            client.close();
        }

    }

    public Jedis createRedisClient() {
        Jedis client = new Jedis(getHost(), getPort());
        if (StringUtils.isNotEmpty(getPassword())) {
            client.auth(getPassword());
        }
        return client;
    }

    @Override
    public java.sql.Connection createConnection() throws Exception {
        return Connection.IGNORE;
    }

    @Override
    public String[] summary(String... args) {
        if (ArrayUtils.isEmpty(args)) {
            return ArrayUtils.EMPTY_STRING_ARRAY;
        } else {
            Set<String> keys = createRedisClient().keys(args[0]);
            return keys.toArray(new String[0]);
        }
    }

    @Override
    public String connectMessage(boolean status) {
        if (status) {
            return InterProviderFactory.getProvider().getLocText("Plugin-Redis_Connection_Successfully") + "!";
        } else {
            return InterProviderFactory.getProvider().getLocText("Plugin-Redis_Connection_Failed") + "!";
        }
    }

    @Override
    public void addConnection(List<String> list, String connectionName, Class<? extends Connection>[] acceptTypes) {
        for (Class<? extends com.fr.data.impl.Connection> accept : acceptTypes) {
            if (StableUtils.classInstanceOf(getClass(), accept)) {
                list.add(connectionName);
                break;
            }
        }
    }

    @Override
    public String getDriver() {
        return null;
    }

    @Override
    public String getOriginalCharsetName() {
        return null;
    }

    @Override
    public void setOriginalCharsetName(String s) {

    }

    @Override
    public String getNewCharsetName() {
        return null;
    }

    @Override
    public void setNewCharsetName(String s) {

    }

    @Override
    public void readXML(XMLableReader reader) {
        super.readXML(reader);
        if (reader.isChildNode()) {
            String tagName = reader.getTagName();
            if ("Attr".equals(tagName)) {
                setHost(reader.getAttrAsString("host", StringUtils.EMPTY));
                setPort(reader.getAttrAsInt("port", DEFAULT_REDIS_PORT));
                String pwd = reader.getAttrAsString("password", StringUtils.EMPTY);
                if (StringUtils.isNotEmpty(pwd)) {
                    setPassword(SecurityToolbox.encrypt(pwd));
                }
            }
        }
    }

    @Override
    public void writeXML(XMLPrintWriter writer) {
        super.writeXML(writer);
        writer.startTAG("Attr");
        writer.attr("host", getHost());
        writer.attr("port", getPort());
        if (StringUtils.isNotEmpty(getPassword())) {
            writer.attr("password", SecurityToolbox.decrypt(getPassword()));
        }
        writer.end();
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        com.fr.plugin.db.redis.core.RedisDatabaseConnection cloned = (com.fr.plugin.db.redis.core.RedisDatabaseConnection) super.clone();
        cloned.host = (Conf<String>) host.clone();
        cloned.port = (Conf<Integer>) port.clone();
        cloned.password = (Conf<String>) password.clone();
        return cloned;
    }
}