package de.mrbesen.telegram;

import de.mrbesen.telegram.AsyncHandler.Callback;
import de.mrbesen.telegram.AsyncHandler.Task;
import de.mrbesen.telegram.MessageBuilder.AsyncSendable;
import de.mrbesen.telegram.MessageBuilder.SendableMessage;
import de.mrbesen.telegram.commands.CommandManager;
import de.mrbesen.telegram.commands.FeedbackCommand;
import de.mrbesen.telegram.event.Event;
import de.mrbesen.telegram.event.EventManager;
import de.mrbesen.telegram.event.events.*;
import de.mrbesen.telegram.log.Log;
import de.mrbesen.telegram.log.Log4JLog;
import de.mrbesen.telegram.log.SimpleLog;
import de.mrbesen.telegram.objects.JSONBased.Member;
import de.mrbesen.telegram.objects.TFile;
import de.mrbesen.telegram.objects.TMessage;
import de.mrbesen.telegram.objects.TReplyMarkup;
import de.mrbesen.telegram.objects.TUser;
import de.mrbesen.telegram.objects.TUser.Status;
import lombok.Getter;
import lombok.Setter;
import org.json.JSONArray;
import org.json.JSONObject;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.ConnectException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.*;
import java.util.function.*;
import java.util.stream.Collector;

import static java.util.stream.Collector.Characteristics.IDENTITY_FINISH;
import static java.util.stream.Collector.Characteristics.UNORDERED;

public class TelegramAPI implements Runnable {

	private static final String API_URL_DEFAULT = "https://api.telegram.org/bot";
	private static final String TOKENREGEX = "^\\d{4,10}:[\\w-]{12,64}$";
	private static final int TELEGRAMFILESIZELIMIT = 20000000;//20MB filesize https://core.telegram.org/bots/api#sending-files
	public static final String APIVERSION = "3.10";//Jan 16, 2021

	private int msg_offset = 0;
	private int updateInterval = 60;
	private String apikey;
	private String botname;
	private Thread thread;
	private boolean run = true;
	@Getter @Setter
	private boolean longpolling = true;
	@Setter @Getter
	private boolean disableFeedback = false;
	private String apiurl;

	private String helpmessage = "generic helppage\nuse TelegramAPI.setHelpText(java.lang.String) to change this.";

	//stats
	protected int fetchedUpdates = 0;
	protected long start = 0;

	private Map<Long, TUser> users = new TreeMap<>();
	@Setter
	private List<Long> admins = new LinkedList<>(); //required for feedback
	private CommandManager cmdmgr = new CommandManager(this);
	private EventManager evntmgr = new EventManager();

	private FeedbackCommand feedbackCmd = null;

	//async
	private AsyncHandler async = null;
	public static Callback<Throwable, Void> IOE400supressor = new Callback<Throwable, Void>() {
		@Override
		public Void call(Throwable t) throws Throwable {
			if(t instanceof IOException) {
				if(t.getMessage().startsWith("Server returned HTTP response code: 400"))
					return null;
			}
			throw t;
		}
	};

	Log log = new Log4JLog();

	/**
	 * please only use if bot is not used in groups
	 * @param apikey
	 */

	public TelegramAPI(String apikey) { this(null, apikey); }

	public TelegramAPI(String apiurl, String apikey) {
		this(apiurl, apikey, "");
	}

	public TelegramAPI(String apiurl, String apikey, String botname) {
		this.apiurl = (apiurl == null ?  API_URL_DEFAULT : apiurl);
		this.botname = botname != null ? botname : "";

		if (!apikey.matches(TOKENREGEX) ) {
			throw new IllegalArgumentException("Invalid API key: " + apikey);
		}
		this.apiurl += this.apikey = apikey;
	}

	public void start() {
		start(1);
	}

	//start with a specified threadcount for async operations
	public void start(int threadCount) {
		if(thread == null) {
			async = new AsyncHandler(this, threadCount);
			if(!disableFeedback) {
				//init Feedback
				feedbackCmd = new FeedbackCommand(this, admins);
				cmdmgr.registerCommand("feedback", feedbackCmd);
			}
			run = true;
			thread = new Thread(this, "TelegramAPI");
			thread.start();
		} else {
			throw new IllegalStateException("Still Running.");
		}
	}

	public void addAdmin(long admin) {
		admins.add(admin);
	}

	public boolean isAdmin(long admin) { return admins.contains(admin); }

	public void request(Task task) {
		async.enque(task);
	}

	public void requestAsync(String request, String parameter, long userid) {
		this.async.enque(request, parameter, userid);
	}

	public JSONObject request(String request, String parameter, long userid) throws IOException {
		return request(request, parameter, userid,true);
	}

	public JSONObject request(String request, String parameter, long userid, boolean logging) throws IOException {
		//do https stuff
		boolean toomany = true; //für retry after 429 error
		int trycount = 0;
		while(toomany) {
			toomany = false;
			++trycount;
			URL url = new URL(apiurl + "/" + request);
			HttpURLConnection con = (HttpURLConnection) url.openConnection();
			con.setDoInput(true);
			con.setDoOutput(true);
			OutputStreamWriter wr = new OutputStreamWriter(con.getOutputStream());
			wr.write(parameter);
			wr.flush();

			if (logging) {
				String small = parameter;
				if (small.length() > 60) {
					small = small.substring(0, Math.min(60, small.length())) + "...";
				}
				log.log("request: " + request + " content " + small + " -> " + con.getResponseCode() + " " + con.getResponseMessage());
			}
			int response = con.getResponseCode();
			if (response == 200) {
				return new JSONObject(readfromIS(con.getInputStream()));
			} else {
				String errdesc = "[No description available]";
				try {
					//try to read error message
					JSONObject returned = new JSONObject(readfromIS(con.getErrorStream()));
					errdesc = returned.getString("description");
				} catch (Throwable ignore) {
				}

				log.log("Request failed error: \"" + errdesc + "\" detailed request: " + request + "?" + parameter);

				//catch 429 too many error
				if (response == 429) {
					if(trycount < 10) toomany = true;

					//try to read timeout
					//too Many Requests: retry after 19
					int timeout = 10;
					int idx = errdesc.lastIndexOf(" ");
					try {
						timeout = Integer.parseInt(errdesc.substring(idx))+1;
						System.out.println("timeout read: " + timeout);
					} catch(NumberFormatException | StringIndexOutOfBoundsException e ) {}
					try {
						System.out.println("Got 429 -> sleep for " + timeout + " seconds");
						Thread.sleep(timeout * 1000);
					} catch(InterruptedException e) {}

					if(trycount < 10) continue;
				} else if(response == 403) {
					if(errdesc.equals("Forbidden: bot was blocked by the user")) {
						if(userid != 0)
							evntmgr.callEvent(new UserBlockedBotEvent(getUser(userid)));
					}
				}

				throw new APIError(parameter, request, con.getResponseCode(), null, errdesc);
				//throw new IOException("API request returned HTTP " + con.getResponseCode() + " (" + con.getResponseMessage() + ") for action " + request + "\nurl: " + url.toString() + "\nparams: " + parameter + "\nerror description: " + errdesc);
			}
		}
		//unreachable code?
		throw new IllegalStateException();
	}

	protected String readfromIS(InputStream is) {
		Scanner s = new Scanner(is);
		StringBuilder sb = new StringBuilder();
		while(s.hasNextLine()) {
			sb.append(s.nextLine()).append('\n');
		}
		s.close();
		return sb.toString();
	}

	public void sendAsync(long chatid, String msg) {
		sendMessage(new MessageBuilder().setAsync().setReciver(chatid).setText(msg).build());
	}

	public TMessage sendMessage(TUser user, String text) {
		MessageBuilder builder = new MessageBuilder();
		builder.setReciver(user.getID());
		builder.setText(text);
		return sendMessage(builder.build());
	}

	public TMessage sendMessage(SendableMessage msg) {
		try {
			if(msg instanceof AsyncSendable) {
				AsyncSendable asyncm = (AsyncSendable) msg;
				Callback<JSONObject, TMessage> adapter = getCallbackAdapter(this);
				adapter.next = asyncm.callback;
				Task t = new Task(msg.getCommand(), msg.getQ(), msg.getUserid(), adapter);
				t.setExceptionhandl(asyncm.excpt == null ? IOE400supressor : asyncm.excpt);
				async.enque(t);
			} else {
				JSONObject o = request(msg.getCommand(), msg.getQ(), msg.getUserid(), true);
				return new TMessage(o.getJSONObject("result"), this);
			}
		} catch(IOException e) {
			log.log("", e);
		}
		return null;
	}

	/**
	 * is always async
	 * @param cmds cmdname -> description
	 */
	public void setBotCommand(Map<String, String> cmds) {
		//build json obj
		JSONArray arr = cmds.entrySet().stream().map(e -> new JSONObject().put("command", e.getKey()).put("description", e.getKey())).collect(new Collector<JSONObject, JSONArray, JSONArray>() {
			@Override
			public Supplier<JSONArray> supplier() {
				return JSONArray::new;
			}

			@Override
			public BiConsumer<JSONArray, JSONObject> accumulator() {
				return JSONArray::put;
			}

			@Override
			public BinaryOperator<JSONArray> combiner() {
				return (a,b) -> { b.forEach(a::put); return b; };
			}

			@Override
			public Function<JSONArray, JSONArray> finisher() {
				return a -> a;
			}

			@Override
			public Set<Characteristics> characteristics() {
				Set<Characteristics> c = new HashSet<>();
				c.add(IDENTITY_FINISH);
				c.add(UNORDERED);
				return c;
			}
		});

		//commit
		Task t = new Task("setMyCommands", "commands=" + arr.toString(), 0, null);
		async.enque(t);
	}

	public void setFeedbackCallback(Function<TUser, String> clb) {
		if(!disableFeedback && feedbackCmd != null)
			feedbackCmd.setFeedbackCallback(clb);
	}

	public TFile getFile(final String fileid) throws IOException {
		JSONObject jfile = request("getFile", "file_id=" + fileid, 0);
		return new TFile(jfile.getJSONObject("result"));
	}

	public void getFile(final String fileid, Consumer<TFile> callback) {
		async.enque(new Task("getFile", "file_id=" + fileid, 0, new Callback<JSONObject, Void>() {
			@Override
			public Void call(JSONObject j) throws Throwable {
				TFile file = new TFile(j.getJSONObject("result"));
				callback.accept(file);
				return null;
			}
		}));
	}

	public void sendTypedMessage(final String msg, final TUser user, final int seconds) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				user.sendStatus(Status.Typing);
				try {
					Thread.sleep(seconds*1000);
				} catch (InterruptedException e) {
				}
				sendMessage(new MessageBuilder().setText(msg).setReciver(user.getID()).build());

			}
		}).start();
	}

	public void answerCallbackQuery(String callbackid, String text, boolean async) {
		if(callbackid == null)
			return;

		if(async) {
			requestAsync("answerCallbackQuery", "callback_query_id=" + callbackid + "&text=" + text, 0);
		} else {
			try {
				request("answerCallbackQuery", "callback_query_id=" + callbackid + "&text=" + text, 0);
			} catch(IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * creates internal APIEror, when message is not modyfied!
	 * @param newCaption
	 * @param chatid
	 * @param msg_id
	 * @param rm
	 * @param async
	 * @param clb
	 */
	public void updateCaption(final String newCaption, long chatid, int msg_id, TReplyMarkup rm, boolean async, Callback<JSONObject, ?> clb) {
		try {
			String rply  = "";
			if(rm != null)
				rply = "&reply_markup=" +  URLEncoder.encode(rm.toJSONString(), "UTF-8");
			String q = "chat_id=" + chatid + "&message_id=" + msg_id + "&caption=" + URLEncoder.encode(newCaption, "UTF-8") + rply;
			if(async) {
				Task t = new Task("editMessageCaption", q, chatid);
				t.setExceptionhandl(new Callback<Throwable, Void>() {
					@Override
					public Void call(Throwable j) throws Throwable {
						if(j instanceof APIError) {
							String errmsg = ((APIError) j).getMessage();
							if(errmsg.equals("Bad Request: message is not modified") || errmsg.equals("Bad Request: message to edit not found")) {
								//both have code 400
								return null;
							}
						}
						throw j;
					}
				});
				this.async.enque(t);
			} else {
				request("editMessageCaption", q, chatid);
			}
		} catch(IOException e) {
			log.log("", e);
		}
	}

	public void updateMarkup(long chatid, int msg_id, TReplyMarkup rm, boolean async) {
		try {
			if(rm == null) return;//nope

			String q = "chat_id=" + chatid + "&message_id=" + msg_id + "&reply_markup=" + URLEncoder.encode(rm.toJSONString(), "UTF-8");

			if(async) {
				this.async.enque("editMessageReplyMarkup", q, chatid);
			} else {
				request("editMessageReplyMarkup", q, chatid);
			}
		} catch(IOException e) {
			log.log("", e);
		}
	}

	public void stop() {
		run = false;
		if(thread == null) return;
		thread.interrupt();
		thread = null;
		log.log("TelegramAPI stoped.");
	}

	@Override
	public void run() {
		start = System.currentTimeMillis();
		if(longpolling) {
			while(run) {
				fetchUpdates();
				fetchedUpdates++;
			}
		} else {
			while(run) {
				long runstart = System.currentTimeMillis();
				fetchUpdates();
				fetchedUpdates++;
				try {
					int wait = (int) (updateInterval - (System.currentTimeMillis() - runstart));
					if(wait > 0)
						Thread.sleep(wait);
				} catch (InterruptedException e) {
					break;
				}
			}
		}
	}

	public boolean isRunning() {
		return thread.isAlive();
	}

	private void fetchUpdates() {
		try {
			processUpdates(request("getUpdates", "offset=" + msg_offset + "&timeout=" + (longpolling ? updateInterval : 1), 0,false));
		} catch (IOException e) {
			log.log("error getting updates.", e);

			try {
				Thread.sleep(e instanceof ConnectException ? 10000 : 500);
			} catch(InterruptedException ignored) {}
		}
	}

	private void processUpdates(JSONObject object) {
		if(object == null)
			return;
		JSONArray arr_results = object.getJSONArray("result");
		for(int i = 0; !arr_results.isNull(i); i++) {
			JSONObject entry = arr_results.getJSONObject(i);
			TelegramAPIUpdate upd = new TelegramAPIUpdate(entry, this);
			msg_offset = (upd.update_id+1 > msg_offset ? upd.update_id+1 : msg_offset);
		}
	}

	public TUser getUser(String name) {
		for(TUser us : users.values()) {
			if(us.getName().equals(name))
				return us;
		}
		return null;
	}

	public TUser getUser(long id, boolean createIfNotExitsts) {
		TUser u = users.get(id);
		if(u != null || !createIfNotExitsts)
			return u;
		u = new TUser(id, this);
		evntmgr.callEvent(new NewUserEvent(u));
		users.put(id, u);
		return u;
	}

	public TUser getUser(long id) {
		return getUser(id, true);
	}

	/**
	 * gets a user by id from the known user lists,
	 * if no user found, it creates a new User and adds it to the list.
	 * @param json
	 * @return
	 */
	public TUser getUser(JSONObject json) {
		long id = json.getLong("id");
		TUser user = getUser(id, false);
		if(user != null)
			return user;
		user = new TUser(json, this);
		users.put(id, user);
		return user;
	}

	public void setHelpText(String helptext) {
		helpmessage = ( helptext == null ? "" : helptext);
	}

	/**
	 * Set the logging method, use {@link Log4JLog} for usage of LOG4J,
	 * or {@link SimpleLog} for usage of System.out.println();
	 * use Null t odisable logging the default is {@link SimpleLog}
	 * @param l
	 */
	public void setLog(Log l) {
		if(l == null)
			log = new Log();
		else
			log = l;
	}

	public CommandManager getCommandManager() {
		return cmdmgr;
	}

	public EventManager getEventManager() {
		return evntmgr;
	}

	/**
	 * seconds to wait for longpolling or milliseconds to wait between shortpolling
	 * @param d
	 */
	public void setUpdateInterval(int d) {
		if(d < 0)
			throw new IllegalArgumentException("UpdateInterval is not allowed to be negative.");
		updateInterval = d;
	}

	public String getHelpMessage() {
		return helpmessage;
	}

	public int getupdateInterval() {
		return updateInterval;
	}

	public float getUpdatesperSecond() {
		if(start == 0)
			return -1;
		return fetchedUpdates / ((float) (System.currentTimeMillis() - start) / 1000);
	}

	public static boolean isSendable(long filesize) {
		return filesize < TELEGRAMFILESIZELIMIT;
	}

	public static Callback<JSONObject, TMessage> getCallbackAdapter(TelegramAPI api) {
		return new Callback<JSONObject, TMessage>() {
			@Override
			public TMessage call(JSONObject j) {
				return new TMessage(j.getJSONObject("result"), api);
			}
		};
	}

	protected class TelegramAPIUpdate {
		protected int update_id = 0;
		private TMessage msg = null;

		protected TelegramAPIUpdate(JSONObject json, TelegramAPI api) {
			update_id = json.getInt("update_id");

			if(json.has("message")) {
				msg = new TMessage(json.getJSONObject("message"), api);

				String text = msg.getText();
				if(text != null) {
					if(text.matches("^\\/(\\w+)(@(\\w+))?(\\s.*)?")) { //is a command
						text = text.substring(1);//remove '/'
						if(text.contains("@")) {//check name
							int at = text.indexOf('@');
							int end = text.indexOf(' ', at+1);
							if(end == -1)
								end = text.length();
							String botname = text.substring(at+1, end);
							if(botname.equalsIgnoreCase(api.botname)) {
								cmdmgr.onCommand(text, msg.getFrom(), msg);
							} else
								api.log.log("other botname found: " + botname);
						} else {
							cmdmgr.onCommand(text, msg.getFrom(), msg);
						}
					} else {
						Event e = new UserSendMessageEvent(msg);
						//call feedback cmd first
						if(!disableFeedback) {
							if (feedbackCmd.onMsg((UserSendMessageEvent) e)) {
								e = null;
							}
						}
						getEventManager().callEvent(e);
						return; //do not process other events
					}
				}

				Event e = null;
				//process media events
				if(msg.has(Member.audio)) {
					e = new UserSendAudioEvent(msg);
				} else if(msg.has(Member.video)) {
					//TODO
				} else if(msg.has(Member.document)) {
					e = new UserSendDocumentEvent(msg);
				} else if(msg.has(Member.photo)) {
					e = new UserSendPhotoEvent(msg);
				} else if(msg.has(Member.invoice)) {
					//TODO
				} else if(msg.has(Member.location)) {
					//TODO
				} else if(msg.has(Member.video_note)) {
					//TODO
				} else if(msg.has(Member.game)) {
					//TODO
				} else if(msg.has(Member.contact)) {
					//TODO
				} else if(msg.has(Member.sticker)) {
					//TODO
				}
				getEventManager().callEvent(e);
			} else if(json.has("callback_query")) {
				JSONObject cbq = json.getJSONObject("callback_query");
				TUser from = api.getUser(cbq.getJSONObject("from"));
				String data = cbq.getString("data");
				String id = cbq.getString("id");
				TMessage msg = new TMessage(cbq.getJSONObject("message"), api);
				UserCallbackEvent event = new UserCallbackEvent(from, data, id, msg);

				if(!disableFeedback) {
					if (!feedbackCmd.onCallback(event))
						getEventManager().callEvent(event);
				} else {
					getEventManager().callEvent(event);
				}
			}
		}
	}

	public enum JSONObjectType {
		User,
		Chat,
		Message,
		MessageEntity,
		Audio,
		Document,
		Game,
		Sticker,
		Video,
		Voice,
		Videonote,
		Location,
		Venue,
		Contact;

		boolean isArray = false;
		void setArray(boolean b) {
			isArray = b;
		}
	}

	public class APIError extends IOException {
		/**
		 *
		 */
		private static final long serialVersionUID = 1L;
		String params;
		String method;
		int returncode;
		public String getParams() {
			return params;
		}
		public String getMethod() {
			return method;
		}
		public int getReturncode() {
			return returncode;
		}
		public void setParams(String params) {
			this.params = params;
		}
		public void setMethod(String method) {
			this.method = method;
		}
		public void setReturncode(int returncode) {
			this.returncode = returncode;
		}
		public APIError(String params, String method, int returncode, Throwable t, String msg) {
			super(msg, t);
			this.params = params;
			this.method = method;
			this.returncode = returncode;
		}
		public APIError(String arg0, Throwable arg1) {
			super(arg0, arg1);
		}
		public APIError(String arg0) {
			super(arg0);
		}
		public APIError(Throwable arg0) {
			super(arg0);
		}
	}
}