# encoding=utf-8
# MIT License
#
# Copyright (c) 2023 TommyLemon
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.

import json
from unitauto import methodutil
from unitauto.methodutil import null, true, false, to_json_str, list_method, invoke_method, KEY_PACKAGE, KEY_CLASS, \
 KEY_CONSTRUCTOR, KEY_CLASS_ARGS, KEY_THIS, KEY_METHOD, KEY_METHOD_ARGS, KEY_TYPE, KEY_VALUE, KEY_RETURN, KEY_KEY, \
 KEY_ASYNC, KEY_CALLBACK

from http.server import HTTPServer, BaseHTTPRequestHandler


CHARSET = 'uft-8'
HOST = ('localhost', 8083)

RESPONSE_CODE_SUCCESS = 200
KEY_CONTENT_TYPE = 'Content-Type'
KEY_CONTENT_LENGTH = 'Content-Length'
CONTENT_TYPE = 'application/json; charset=UTF-8'


class Request(BaseHTTPRequestHandler):
 timeout = 5
 server_version = "Apache"

 def send_headers(self, origin, method='POST'):
 self.send_header(KEY_CONTENT_TYPE, CONTENT_TYPE)
 self.send_header('Access-Control-Allow-Origin', origin)
 self.send_header('Access-Control-Allow-Credentials', 'true')
 self.send_header('Access-Control-Allow-Headers', 'Content-Type,content-type')
 self.send_header('Access-Control-Allow-Methods', 'POST,GET,OPTIONS')
 self.send_header('Access-Control-Request-Method', method)

 self.end_headers()

 def do_OPTIONS(self):
 self.do_POST()

 def do_POST(self):
 method = self.command
 client_address = self.client_address
 host = 'http://' + client_address[0] + ':' + str(client_address[1])
 path = self.path
 print(method + ' ' + host + path)
 if path not in ['/method/list', '/method/invoke']:
 raise Exception('only support /method/list, /method/invoke')

 origin = self.headers.get('origin') or self.headers.get('Origin') or 'http://apijson.cn'

 if method == 'OPTIONS':
 self.send_response(RESPONSE_CODE_SUCCESS)
 self.send_headers(origin, method)
 # self.wfile.write('ok'.encode())
 return

 bs = self.rfile.read(int(self.headers[KEY_CONTENT_LENGTH]))
 req = bs.decode() # bs.decode(CHARSET)
 # req = urllib.unquote(bs).decode(CHARSET, 'ignore')

 done = [false]

 wfile = self.wfile

 def callback(res):
 res_str = to_json_str(res)
 res_byte = res_str.encode()
 self.send_response(RESPONSE_CODE_SUCCESS)
 self.send_headers(origin, method)
 if done[0] or wfile is None or wfile.closed:
 return

 wfile.write(res_byte)
 done[0] = true
 try:
 wfile.close()
 except BaseException as e:
 # print(e)
 pass
 # cause error 'unresolved reference' wfile = null

 if path == '/method/list':
 rsp = list_method(req)
 callback(rsp)
 else:
 invoke_method(req, callback)
 while true:
 if done[0]:
 break


def start(host=HOST):
 server = HTTPServer(host, Request)
 print("Starting server, listen at: %s:%s" % host)
 server.serve_forever()


def test():
 rsp0 = invoke_method({
 KEY_PACKAGE: 'unitauto.test',
 KEY_METHOD: 'test'
 })
 print('\nunitauto.test.test() = \n' + to_json_str(rsp0))

 rsp1 = invoke_method({
 KEY_PACKAGE: 'unitauto.test',
 KEY_CLASS: 'testutil',
 KEY_METHOD: 'minus',
 KEY_METHOD_ARGS: [
 {
 KEY_TYPE: 'int',
 KEY_VALUE: 2
 },
 {
 KEY_TYPE: 'int',
 KEY_VALUE: 3
 }
 ]
 })
 print('\nunitauto.test.testutil.minus(2, 3) = \n' + to_json_str(rsp1))

 rsp2 = invoke_method({
 KEY_PACKAGE: 'unitauto.test',
 KEY_CLASS: 'testutil$Test',
 KEY_CLASS_ARGS: [
 1,
 0,
 'UnitAuto'
 ],
 KEY_METHOD: 'get_id'
 })
 print('\nunitauto.test.testutil.Test.get_id() = \n' + to_json_str(rsp2))

 rsp3 = invoke_method({
 KEY_PACKAGE: 'unitauto.test',
 KEY_CLASS: 'testutil$Test',
 KEY_CONSTRUCTOR: 'get_test_instance',
 KEY_CLASS_ARGS: [
 2,
 1,
 'UnitAuto@Python'
 ],
 KEY_METHOD: 'get_name'
 })
 print('\nunitauto.test.testutil.Test.get_name() = \n' + to_json_str(rsp3))

 rsp4 = invoke_method({
 KEY_PACKAGE: 'unitauto.test',
 KEY_CLASS: 'testutil$Test',
 KEY_THIS: {
 KEY_TYPE: 'unitauto.test.testutil$Test',
 KEY_VALUE: {
 'id': 3,
 'sex': 1,
 'name': 'UnitAuto'
 }
 },
 KEY_METHOD: 'get_sex_str'
 })
 print('\nunitauto.test.testutil.Test.get_sex_str() = \n' + to_json_str(rsp4))

 rsp5 = invoke_method({
 KEY_ASYNC: true,
 KEY_PACKAGE: 'unitauto.test',
 KEY_CLASS: 'testutil',
 KEY_METHOD: 'async_test',
 KEY_METHOD_ARGS: [
 {
 KEY_TYPE: 'int',
 KEY_VALUE: 2
 },
 {
 KEY_TYPE: 'int',
 KEY_VALUE: 5
 }
 ]
 })
 print('\nunitauto.test.testutil.async_test(2, 5) = \n' + to_json_str(rsp5))

 def callback(rsp):
 print('unitauto.test.testutil.compute_async(2, 5, callback) = \n' + to_json_str(rsp))

 rsp6 = invoke_method({
 KEY_PACKAGE: 'unitauto.test',
 KEY_CLASS: 'testutil',
 KEY_METHOD: 'compute_async',
 KEY_METHOD_ARGS: [
 {
 # KEY_KEY: 'a',
 KEY_TYPE: 'int',
 KEY_VALUE: 2
 },
 {
 # KEY_KEY: 'b',
 KEY_TYPE: 'int',
 KEY_VALUE: 5
 },
 {
 KEY_KEY: 'callback',
 KEY_TYPE: 'def(a,b)',
 KEY_VALUE: {
 KEY_TYPE: 'int',
 KEY_RETURN: 'a - b',
 KEY_CALLBACK: true
 }
 }
 ]
 }, callback)
 print('\nunitauto.test.testutil.compute_async(2, 5, callback) = \n' + to_json_str(rsp6))


if __name__ == '__main__':
 test()
 start()