package org.example;

import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.type.WritableTypeId;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import com.fasterxml.jackson.dataformat.xml.XmlMapper;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import com.fasterxml.jackson.dataformat.xml.ser.ToXmlGenerator;
import org.example.TextMessage;

import java.io.IOException;
import java.io.Serializable;

public class Main {
    public static void main(String[] args) throws IOException {
        XmlMapper xmlMapper = new XmlMapper();
        xmlMapper.setSerializerFactory(xmlMapper.getSerializerFactory()
                .withSerializerModifier(new ServerMessageSerializerModifier()));

        ServerMessage.LoginResponse loginResponse = new ServerMessage.LoginResponse(12345);
        String serializedLoginResponse = xmlMapper.writeValueAsString(loginResponse);
        System.out.println("Serialized LoginResponse: " + serializedLoginResponse);
    }
}

@JacksonXmlRootElement(localName = "ServerMessage")
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes({
        @JsonSubTypes.Type(value = ServerMessage.LoginResponse.class, name = "login_response"),
        @JsonSubTypes.Type(value = ServerMessage.NewMessage.class, name = "new_message")
})
abstract class ServerMessage implements Serializable {
    public enum ErrorType {
        ERROR, SUCCESS
    }


    @JsonIgnore
    @JacksonXmlProperty(isAttribute = false)
    private final ErrorType errorType;

    @JsonCreator
    protected ServerMessage(@JsonProperty("errorType") ErrorType errorType) {
        this.errorType = errorType != null ? errorType : ErrorType.SUCCESS;
    }
    @JsonIgnore
    public ErrorType getErrorType() {
        return errorType;
    }

    public static final class LoginResponse extends ServerMessage {
        private final int sessionID;

        public LoginResponse(int sessionId) {
            super(ErrorType.SUCCESS);
            this.sessionID = sessionId;
        }

        @JsonCreator(mode = JsonCreator.Mode.DISABLED)
        public LoginResponse() {
            super(ErrorType.SUCCESS);
            this.sessionID = 0; // or any default value you prefer
        }

        @JsonProperty("sessionID")
        @JacksonXmlProperty(localName = "sessionID")
        public int getSessionID() {
            return sessionID;
        }
    }

    public static final class NewMessage extends ServerMessage {
        private TextMessage message;

        public NewMessage() {
            super(ErrorType.SUCCESS);
        }

        public NewMessage(TextMessage message) {
            super(ErrorType.SUCCESS);
            this.message = message;
        }

        @JsonProperty("message")
        @JacksonXmlProperty(localName = "message")
        public TextMessage getMessage() {
            return message;
        }
    }

    public static String serialize(ServerMessage message) throws IOException {
        XmlMapper xmlMapper = new XmlMapper();
        return xmlMapper.writer().withRootName(message.getErrorType().name()).writeValueAsString(message);
    }

    public static ServerMessage deserialize(String xml) throws IOException {
        XmlMapper xmlMapper = new XmlMapper();
        xmlMapper.registerSubtypes(LoginResponse.class, NewMessage.class);
        xmlMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        return xmlMapper.readValue(xml, ServerMessage.class);
    }
}

class ServerMessageSerializerModifier extends BeanSerializerModifier {
    @Override
    public JsonSerializer<?> modifySerializer(
            SerializationConfig config, BeanDescription beanDesc, JsonSerializer<?> serializer) {
        if (ServerMessage.class.isAssignableFrom(beanDesc.getBeanClass())) {
            return new ServerMessageSerializer((JsonSerializer<Object>) serializer);
        }
        return serializer;
    }
}


class ServerMessageSerializer extends JsonSerializer<Object> {
    private final StdSerializer<?> defaultSerializer;
    private final XmlMapper xmlMapper;

    ServerMessageSerializer(StdSerializer<?> defaultSerializer, XmlMapper xmlMapper) {
        this.defaultSerializer = defaultSerializer;
        this.xmlMapper = xmlMapper;
    }

    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if (value instanceof ServerMessage serverMessage) {
            gen.writeStartObject();
            gen.writeObjectField("errorType", serverMessage.getErrorType());

            // Start the object for the current field
            gen.writeFieldName(gen.getOutputContext().getCurrentName());
            gen.writeStartObject();

            // Convert the object to XML and write it using the XML generator
            String xml = xmlMapper.writeValueAsString(value);
            ToXmlGenerator xmlGenerator = (ToXmlGenerator) gen;
            xmlGenerator.writeRaw(xml);

            gen.writeEndObject(); // End the object for the current field
            gen.writeEndObject();
        } else {
            defaultSerializer.serialize(value, gen, serializers);
        }
    }
}


java: constructor ServerMessageSerializer in class org.example.ServerMessageSerializer cannot be applied to given types;
  required: com.fasterxml.jackson.databind.ser.std.StdSerializer<?>,com.fasterxml.jackson.dataformat.xml.XmlMapper
  found:    com.fasterxml.jackson.databind.JsonSerializer<java.lang.Object>
  reason: actual and formal argument lists differ in length


149:41   defaultSerializer.serialize(value, gen, serializers);
java: incompatible types: java.lang.Object cannot be converted to capture#1 of ?