@Entity
@DynamicInsert
@DynamicUpdate
@Table(name = "PATENT")
@SequenceGenerator(name = "hibernate_sequence", sequenceName = "hibernate_sequence", initialValue = 1, allocationSize = 50)
@Indexed
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
@AnalyzerDefs(value = {
        @AnalyzerDef(name = "titleAnalyzer",
                tokenizer = @TokenizerDef(factory = StandardTokenizerFactory.class),
                filters = {
                        @TokenFilterDef(factory = LowerCaseFilterFactory.class),
                        @TokenFilterDef(factory = StopFilterFactory.class),
                        @TokenFilterDef(factory = SnowballPorterFilterFactory.class, params = {
                                @Parameter(name = "language", value = "English")
                        })
                }),
        @AnalyzerDef(name = "applicantsAnalyzer",
                tokenizer = @TokenizerDef(factory = StandardTokenizerFactory.class),
                filters = {
                        @TokenFilterDef(factory = LowerCaseFilterFactory.class),
                        @TokenFilterDef(factory = StopFilterFactory.class),
                        @TokenFilterDef(factory = SynonymFilterFactory.class, params = {
                                @Parameter(name = "synonyms", value = "syn.txt")
                        })
                })
})
public class Patent implements Serializable {

    private static final long serialVersionUID = 2875548131187739523L;

    @Id
    @Column(name = "ID")
    @GeneratedValue(generator = "hibernate_sequence", strategy = GenerationType.SEQUENCE)
    @DocumentId
    private Long id;

    @Column(name = "EPO_ID", unique = true, nullable = true)
    private Long epoId;


    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "PATENT_ID", referencedColumnName = "ID")
    @IndexedEmbedded
    private Set<PatentTitle> title;

    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "PATENT_ID", referencedColumnName = "ID")
    private Set<PatentDescription> description;


    @ManyToMany(fetch = FetchType.EAGER, cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
    @JoinTable(name = "PATENT_APPLICANT",
            joinColumns = @JoinColumn(name = "PATENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "APPLICANT_ID")
    )
    @Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
    @OrderColumn(name = "applicant_seq")
    @IndexedEmbedded
    private List<PatentInitiator> applicants;


    @ManyToMany(fetch = FetchType.EAGER, cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
    @JoinTable(name = "PATENT_INVENTOR",
            joinColumns = @JoinColumn(name = "PATENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "AUTHOR_ID")
    )
    @Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
    @OrderColumn(name = "author_seq")
    @IndexedEmbedded
    private List<PatentInitiator> authors;


    @ManyToMany(fetch = FetchType.EAGER, cascade = {CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH})
    @Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
    @JoinTable(name = "PATENT_CLASS",
            joinColumns = @JoinColumn(name = "PATENT_ID"),
            inverseJoinColumns = @JoinColumn(name = "ID"))
    @IndexedEmbedded
    private Set<Classification> ipc;


    @Column(name = "FAMILY_ID", length = 20)
    private Long familyId;


    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinColumn(name = "PATENT_ID", referencedColumnName = "ID")
    @OrderBy("recordDate ASC")
    @Fields({
            @Field(name = "trace.number", store = Store.YES, analyze = Analyze.NO, bridge = @FieldBridge(impl = PatentTraceNumberBridge.class)),
            @Field(name = "trace.fillingDate", store = Store.YES, analyze = Analyze.NO, bridge = @FieldBridge(impl = PatentTraceFillingDateBridge.class)),
            @Field(name = "trace.lastRecordDate", store = Store.YES, analyze = Analyze.NO, bridge = @FieldBridge(impl = PatentTraceLastRecordDateBridge.class)),
    })
    @Fetch(FetchMode.SUBSELECT)
    @IndexedEmbedded
    private List<PatentTrace> trace;

    public List<PatentInitiator> getApplicants() {
        return applicants;
    }

    public void setApplicants(List<PatentInitiator> applicants) {
        this.applicants = applicants;
    }

    public List<PatentInitiator> getAuthors() {
        return authors;
    }

    public void setAuthors(List<PatentInitiator> authors) {
        this.authors = authors;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getEpoId() {
        return epoId;
    }

    public void setEpoId(Long epoId) {
        this.epoId = epoId;
    }

    public Set<PatentTitle> getTitle() {
        return title;
    }

    public void setTitle(Set<PatentTitle> title) {
        this.title = title;
    }

    public Set<PatentDescription> getDescription() {
        return description;
    }

    public void setDescription(Set<PatentDescription> description) {
        this.description = description;
    }

    public Set<Classification> getIpc() {
        return ipc;
    }

    public void setIpc(Set<Classification> ipc) {
        this.ipc = ipc;
    }

    public List<PatentTrace> getTrace() {
        return trace;
    }

    public void setTrace(List<PatentTrace> trace) {
        this.trace = trace;
    }

    public Long getFamilyId() {
        return familyId;
    }

    public void setFamilyId(Long familyId) {
        this.familyId = familyId;
    }


    public void initialize() {
        if (title == null) {
            title = new HashSet<>();
        }
        if (description == null) {
            description = new HashSet<>();
        }
        if (ipc == null) {
            ipc = new HashSet<>();
        }
        if (applicants == null) {
            applicants = new LinkedList<>();
        }
        if (authors == null) {
            authors = new LinkedList<>();
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (obj == this) {
            return true;
        }
        if (obj.getClass() != getClass()) {
            return false;
        }
        Patent rhs = (Patent) obj;
        return new EqualsBuilder()
                .append(this.title, rhs.title)
                .append(this.applicants, rhs.applicants)
                .append(this.authors, rhs.authors)
                .append(this.ipc, rhs.ipc)
                .isEquals();
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder()
                .append(title)
                .append(applicants)
                .append(authors)
                .append(ipc)
                .toHashCode();
    }


    @Override
    public String toString() {
        return new ToStringBuilder(this)
                .append("id", id)
                .append("title", title)
                .append("applicants", applicants)
                .append("authors", authors)
                .append("ipc", ipc)
                .append("familyId", familyId)
                .append("trace", trace)
                .toString();
    }

@Entity
@DynamicInsert
@DynamicUpdate
@Table(name = "CLASSIFICATION", uniqueConstraints = @UniqueConstraint(columnNames = {"CLASS_CODE"}))
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
public class Classification implements Serializable {

    private static final long serialVersionUID = -3092795599286682284L;

    @Id
    @Column(name = "CLASS_CODE", length = 15)
    @Field(name = "class", store = Store.YES, analyze = Analyze.NO)
    @Facet(forField = "class")
    private String code;

    @Column(name = "DESCRIPTION", length = 1000)
    private String description;

    @Column(name = "LEVEL")
    private Integer level;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "PARENT")
    @IndexedEmbedded(depth = 1)
    private Classification parent;

    @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Classification> children;

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public Integer getLevel() {
        return level;
    }

    public void setLevel(Integer level) {
        this.level = level;
    }

    public Classification getParent() {
        return parent;
    }

    public void setParent(Classification parent) {
        this.parent = parent;
    }

    public Set<Classification> getChildren() {
        return children;
    }

    public void setChildren(Set<Classification> children) {
        this.children = children;
    }

    @Override
    public int hashCode() {
        return new HashCodeBuilder()
                .append(this.code)
                .toHashCode();
    }

    @Override
    public boolean equals(Object other) {
        if (other == null) {
            return false;
        }
        if (other == this) {
            return true;
        }
        if (other.getClass() != this.getClass()) {
            return false;
        }
        Classification that = (Classification) other;
        return new EqualsBuilder()
                .append(this.code, that.code)
                .isEquals();
    }

    @Override
    public String toString() {
        return "Classification{" +
                "code='" + code + '\'' +
                ", description='" + description + '\'' +
                ", level=" + level +
                '}';
    }
}